update module to own version

Currently, a translation that doesn't exist just defaults to the
passed message ID.

It can be helpful to be able to catch these missing cases e.g. to
save to a log.

This PR implements variants ending in 'E' like GetE, GetNE.

This wasn't implemented at the package-level scope, because for
quick translations like that the extra flexibility probably isn't
needed.

.github/ISSUE_TEMPLATE.md

@@ -0,0 +1,14 @@
+# Please describe your issue
+
+### Is this a bug, an improvement, a proposal or something else? Describe it.
+
+...
+
+
+### What's the expected behaviour, the current behaviour and the steps to reproduce it?
+
+... 
+
+
+### Comments
+

.github/PULL_REQUEST_TEMPLATE.md

@@ -0,0 +1,23 @@
+# Before creating your Pull Request...
+
+- New Pull Requests should include a good description of what's being merged. 
+- Ideally, all Pull Requests are preceded by a discussion initiated in an Issue on this repository. 
+- For bug fixes is mandatory to have tests that cover and fail when the bug is present and will pass after this Pull Request.
+- For changes and improvements, new tests have to be provided to cover the new features.
+
+
+## Is this a fix, improvement or something else?
+
+...
+
+
+## What does this change implement/fix?
+
+... 
+
+
+## I have ...
+
+- [ ] answered the 2 questions above,
+- [ ] discussed this change in an issue,
+- [ ] included tests to cover this changes.

.github/workflows/build.yml

@@ -0,0 +1,35 @@
+name: Gotext build
+
+on:
+  push:
+    branches: [ master ]
+  pull_request:
+    branches: [ master ]
+
+jobs:
+  build:
+    name: Build
+    runs-on: ubuntu-latest
+    steps:
+
+    - name: Set up Go 1.13
+      uses: actions/setup-go@v1
+      with:
+        go-version: 1.13
+      id: go
+
+    - name: Check out code into the Go module directory
+      uses: actions/checkout@v2
+
+    - name: Get dependencies
+      run: |
+        go get -v -u -t -d ./...
+
+    - name: Build package
+      run: go build -v .
+
+    - name: Install xgotext CLI
+      run: go install -v git.deineagentur.com/DeineAgenturUG/gotext/cli/xgotext
+
+    - name: Test
+      run: go test -v -race ./...

.gitignore

@@ -3,6 +3,9 @@
 .settings
 .buildpath
 
+# golang jetbrains shit
+.idea
+
 # Compiled Object files, Static and Dynamic libs (Shared Objects)
 *.o
 *.a

.travis.yml

@@ -1,7 +1,8 @@
 language: go
-script: go test -v -race ./...
 
 go:
-  - 1.5
-  - 1.6
-  - tip
+  - "1.9"
+  - "1.10"
+  - "1.11"
+  - "1.12"
+  - "tip"

CODE_OF_CONDUCT.md

@@ -0,0 +1,46 @@
+# Contributor Covenant Code of Conduct
+
+## Our Pledge
+
+In the interest of fostering an open and welcoming environment, we as contributors and maintainers pledge to making participation in our project and our community a harassment-free experience for everyone, regardless of age, body size, disability, ethnicity, gender identity and expression, level of experience, nationality, personal appearance, race, religion, or sexual identity and orientation.
+
+## Our Standards
+
+Examples of behavior that contributes to creating a positive environment include:
+
+* Using welcoming and inclusive language
+* Being respectful of differing viewpoints and experiences
+* Gracefully accepting constructive criticism
+* Focusing on what is best for the community
+* Showing empathy towards other community members
+
+Examples of unacceptable behavior by participants include:
+
+* The use of sexualized language or imagery and unwelcome sexual attention or advances
+* Trolling, insulting/derogatory comments, and personal or political attacks
+* Public or private harassment
+* Publishing others' private information, such as a physical or electronic address, without explicit permission
+* Other conduct which could reasonably be considered inappropriate in a professional setting
+
+## Our Responsibilities
+
+Project maintainers are responsible for clarifying the standards of acceptable behavior and are expected to take appropriate and fair corrective action in response to any instances of unacceptable behavior.
+
+Project maintainers have the right and responsibility to remove, edit, or reject comments, commits, code, wiki edits, issues, and other contributions that are not aligned to this Code of Conduct, or to ban temporarily or permanently any contributor for other behaviors that they deem inappropriate, threatening, offensive, or harmful.
+
+## Scope
+
+This Code of Conduct applies both within project spaces and in public spaces when an individual is representing the project or its community. Examples of representing a project or community include using an official project e-mail address, posting via an official social media account, or acting as an appointed representative at an online or offline event. Representation of a project may be further defined and clarified by project maintainers.
+
+## Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be reported by contacting the project team at leonel.quinteros@gmail.com. The project team will review and investigate all complaints, and will respond in a way that it deems appropriate to the circumstances. The project team is obligated to maintain confidentiality with regard to the reporter of an incident. Further details of specific enforcement policies may be posted separately.
+
+Project maintainers who do not follow or enforce the Code of Conduct in good faith may face temporary or permanent repercussions as determined by other members of the project's leadership.
+
+## Attribution
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 1.4, available at [http://contributor-covenant.org/version/1/4][version]
+
+[homepage]: http://contributor-covenant.org
+[version]: http://contributor-covenant.org/version/1/4/

CONTRIBUTING.md

@@ -0,0 +1,19 @@
+# CONTRIBUTING
+
+This open source project welcomes everybody that wants to contribute to it by implementing new features, fixing bugs, testing, creating documentation or simply talk about it. 
+
+Most contributions will start by creating a new Issue to discuss what is the contribution about and to agree on the steps to move forward. 
+
+## Issues
+
+All issues reports are welcome. Open a new Issue whenever you want to report a bug, request a change or make a proposal.
+
+This should be your start point of contribution. 
+
+
+## Pull Requests
+
+If you have any changes that can be merged, feel free to send a Pull Request. 
+
+Usually, you'd want to create a new Issue to discuss about the change you want to merge and why it's needed or what it solves. 
+

Godeps/Godeps.json

@@ -1,22 +0,0 @@
-{
-	"ImportPath": "github.com/leonelquinteros/gotext",
-	"GoVersion": "go1.6",
-	"GodepVersion": "v74",
-	"Packages": [
-		"./..."
-	],
-	"Deps": [
-		{
-			"ImportPath": "github.com/mattn/anko/ast",
-			"Rev": "a8c68fa2983e7dd5d3472992b1fbe2f7c44261f0"
-		},
-		{
-			"ImportPath": "github.com/mattn/anko/parser",
-			"Rev": "a8c68fa2983e7dd5d3472992b1fbe2f7c44261f0"
-		},
-		{
-			"ImportPath": "github.com/mattn/anko/vm",
-			"Rev": "a8c68fa2983e7dd5d3472992b1fbe2f7c44261f0"
-		}
-	]
-}

Godeps/Readme

@@ -1,5 +0,0 @@
-This directory tree is generated automatically by godep.
-
-Please do not edit.
-
-See https://github.com/tools/godep for more information.

README.md

@@ -1,12 +1,13 @@
-[![GoDoc](https://godoc.org/github.com/leonelquinteros/gotext?status.svg)](https://godoc.org/github.com/leonelquinteros/gotext)
+[![GitHub release](https://img.shields.io/github/release/leonelquinteros/gotext.svg)](https://git.deineagentur.com/DeineAgenturUG/gotext)
+[![MIT license](https://img.shields.io/badge/License-MIT-blue.svg)](LICENSE)
+[![GoDoc](https://godoc.org/git.deineagentur.com/DeineAgenturUG/gotext?status.svg)](https://godoc.org/git.deineagentur.com/DeineAgenturUG/gotext)
+![Gotext build](https://git.deineagentur.com/DeineAgenturUG/gotext/workflows/Gotext%20build/badge.svg?branch=master)
 [![Build Status](https://travis-ci.org/leonelquinteros/gotext.svg?branch=master)](https://travis-ci.org/leonelquinteros/gotext)
-[![Go Report Card](https://goreportcard.com/badge/github.com/leonelquinteros/gotext)](https://goreportcard.com/report/github.com/leonelquinteros/gotext)
+[![Go Report Card](https://goreportcard.com/badge/git.deineagentur.com/DeineAgenturUG/gotext)](https://goreportcard.com/report/git.deineagentur.com/DeineAgenturUG/gotext)
 
 # Gotext
 
-[GNU gettext utilities](https://www.gnu.org/software/gettext) for Go. 
-
-Version: [v1.1.1](https://github.com/leonelquinteros/gotext/releases/tag/v1.1.1)
+[GNU gettext utilities](https://www.gnu.org/software/gettext) for Go.
 
 
 # Features
@@ -17,11 +18,14 @@ Version: [v1.1.1](https://github.com/leonelquinteros/gotext/releases/tag/v1.1.1)
   - Support for variables inside translation strings using Go's [fmt syntax](https://golang.org/pkg/fmt/).
   - Support for [pluralization rules](https://www.gnu.org/software/gettext/manual/html_node/Translating-plural-forms.html).
   - Support for [message contexts](https://www.gnu.org/software/gettext/manual/html_node/Contexts.html).
-- Thread-safe: This package is safe for concurrent use across multiple goroutines. 
+- Support for MO files.
+- Thread-safe: This package is safe for concurrent use across multiple goroutines.
 - It works with UTF-8 encoding as it's the default for Go language.
-- Unit tests available. See coverage: https://gocover.io/github.com/leonelquinteros/gotext
+- Unit tests available.
 - Language codes are automatically simplified from the form `en_UK` to `en` if the first isn't available.
 - Ready to use inside Go templates.
+- Objects are serializable to []byte to store them in cache.
+- Support for Go Modules.
 
 
 # License
@@ -31,28 +35,55 @@ Version: [v1.1.1](https://github.com/leonelquinteros/gotext/releases/tag/v1.1.1)
 
 # Documentation
 
-Refer to the Godoc package documentation at (https://godoc.org/github.com/leonelquinteros/gotext)
+Refer to the Godoc package documentation at (https://godoc.org/git.deineagentur.com/DeineAgenturUG/gotext)
 
 
-# Installation 
+# Installation
 
 ```
-go get github.com/leonelquinteros/gotext
+go get git.deineagentur.com/DeineAgenturUG/gotext
 ```
 
-- There are no requirements or dependencies to use this package. 
+- There are no requirements or dependencies to use this package.
 - No need to install GNU gettext utilities (unless specific needs of CLI tools).
-- No need for environment variables. Some naming conventions are applied but not needed.  
+- No need for environment variables. Some naming conventions are applied but not needed.
 
 
-#### Version vendoring
+## Version vendoring
 
 Stable releases use [semantic versioning](http://semver.org/spec/v2.0.0.html) tagging on this repository.
 
 You can rely on this to use your preferred vendoring tool or to manually retrieve the corresponding release tag from the GitHub repository.
 
 
-##### Vendoring with [gopkg.in](http://labix.org/gopkg.in)
+### Vendoring with [Go Modules](https://github.com/golang/go/wiki/Modules) (Recommended)
+
+Add `git.deineagentur.com/DeineAgenturUG/gotext` inside the  `require` section in your `go.mod` file.
+
+i.e.
+```
+require (
+    git.deineagentur.com/DeineAgenturUG/gotext v1.5.0
+)
+```
+
+
+### Vendoring with [dep](https://golang.github.io/dep/)
+
+To use last stable version (v1.5.0 at the moment of writing)
+
+```
+dep ensure -add git.deineagentur.com/DeineAgenturUG/gotext@v1.5.0
+```
+
+Import as
+
+```go
+import "git.deineagentur.com/DeineAgenturUG/gotext"
+```
+
+
+### Vendoring with [gopkg.in](http://labix.org/gopkg.in)
 
 [http://gopkg.in/leonelquinteros/gotext.v1](http://gopkg.in/leonelquinteros/gotext.v1)
 
@@ -62,7 +93,7 @@ To get the latest v1 package stable release, execute:
 go get gopkg.in/leonelquinteros/gotext.v1
 ```
 
-To import this package, add the following line to your code:
+Import as
 
 ```go
 import "gopkg.in/leonelquinteros/gotext.v1"
@@ -73,19 +104,19 @@ Refer to it as gotext.
 
 # Locales directories structure
 
-The package will assume a directories structure starting with a base path that will be provided to the package configuration 
-or to object constructors depending on the use, but either will use the same convention to lookup inside the base path. 
+The package will assume a directories structure starting with a base path that will be provided to the package configuration
+or to object constructors depending on the use, but either will use the same convention to lookup inside the base path.
 
-Inside the base directory where will be the language directories named using the language and country 2-letter codes (en_US, es_AR, ...). 
-All package functions can lookup after the simplified version for each language in case the full code isn't present but the more general language code exists. 
-So if the language set is `en_UK`, but there is no directory named after that code and there is a directory named `en`, 
-all package functions will be able to resolve this generalization and provide translations for the more general library.  
+Inside the base directory where will be the language directories named using the language and country 2-letter codes (en_US, es_AR, ...).
+All package functions can lookup after the simplified version for each language in case the full code isn't present but the more general language code exists.
+So if the language set is `en_UK`, but there is no directory named after that code and there is a directory named `en`,
+all package functions will be able to resolve this generalization and provide translations for the more general library.
 
-The language codes are assumed to be [ISO 639-1](https://en.wikipedia.org/wiki/List_of_ISO_639-1_codes) codes (2-letter codes). 
+The language codes are assumed to be [ISO 639-1](https://en.wikipedia.org/wiki/List_of_ISO_639-1_codes) codes (2-letter codes).
 That said, most functions will work with any coding standard as long the directory name matches the language code set on the configuration.
 
-Then, there can be a `LC_MESSAGES` containing all PO files or the PO files themselves.  
-A library directory structure can look like: 
+Then, there can be a `LC_MESSAGES` containing all PO files or the PO files themselves.
+A library directory structure can look like:
 
 ```
 /path/to/locales
@@ -110,44 +141,11 @@ A library directory structure can look like:
 /path/to/locales/fr
 /path/to/locales/fr/default.po
 /path/to/locales/fr/extras.po
-``` 
+```
 
 And so on...
 
 
-
-# About translation function names
-
-The standard GNU gettext defines helper functions that maps to the `gettext()` function and it's widely adopted by most implementations. 
-
-The basic translation function is usually `_()` in the form: 
-
-```
-_("Translate this")
-``` 
-
-In Go, this can't be implemented by a reusable package as the function name has to start with a capital letter in order to be exported. 
-
-Each implementation of this package can declare this helper functions inside their own packages if this function naming are desired/needed: 
-
-```go
-package main
-
-import "github.com/leonelquinteros/gotext"
-
-func _(str string, vars ...interface{}) string {
-    return gotext.Get(str, vars...)
-}
-
-``` 
-
-This is valid and can be used within a package.
-
-In normal conditions the Go compiler will optimize the calls to `_()` by replacing its content in place of the function call to reduce the function calling overhead. 
-This is a normal Go compiler behavior.  
-
-
-
 # Usage examples
 
 ## Using package for single language/domain settings
@@ -155,38 +153,44 @@ This is a normal Go compiler behavior.
 For quick/simple translations you can use the package level functions directly.
 
 ```go
-import "github.com/leonelquinteros/gotext"
+import (
+    "fmt"
+    "git.deineagentur.com/DeineAgenturUG/gotext"
+)
 
 func main() {
     // Configure package
     gotext.Configure("/path/to/locales/root/dir", "en_UK", "domain-name")
-    
+
     // Translate text from default domain
-    println(gotext.Get("My text on 'domain-name' domain"))
-    
+    fmt.Println(gotext.Get("My text on 'domain-name' domain"))
+
     // Translate text from a different domain without reconfigure
-    println(gotext.GetD("domain2", "Another text on a different domain"))
+    fmt.Println(gotext.GetD("domain2", "Another text on a different domain"))
 }
 
 ```
 
 ## Using dynamic variables on translations
 
-All translation strings support dynamic variables to be inserted without translate. 
-Use the fmt.Printf syntax (from Go's "fmt" package) to specify how to print the non-translated variable inside the translation string. 
+All translation strings support dynamic variables to be inserted without translate.
+Use the fmt.Printf syntax (from Go's "fmt" package) to specify how to print the non-translated variable inside the translation string.
 
 ```go
-import "github.com/leonelquinteros/gotext"
+import (
+    "fmt"
+    "git.deineagentur.com/DeineAgenturUG/gotext"
+)
 
 func main() {
     // Configure package
     gotext.Configure("/path/to/locales/root/dir", "en_UK", "domain-name")
-    
+
     // Set variables
     name := "John"
-    
+
     // Translate text with variables
-    println(gotext.Get("Hi, my name is %s", name))
+    fmt.Println(gotext.Get("Hi, my name is %s", name))
 }
 
 ```
@@ -194,32 +198,35 @@ func main() {
 
 ## Using Locale object
 
-When having multiple languages/domains/libraries at the same time, you can create Locale objects for each variation 
+When having multiple languages/domains/libraries at the same time, you can create Locale objects for each variation
 so you can handle each settings on their own.
 
 ```go
-import "github.com/leonelquinteros/gotext"
+import (
+    "fmt"
+    "git.deineagentur.com/DeineAgenturUG/gotext"
+)
 
 func main() {
     // Create Locale with library path and language code
     l := gotext.NewLocale("/path/to/locales/root/dir", "es_UY")
-    
+
     // Load domain '/path/to/locales/root/dir/es_UY/default.po'
     l.AddDomain("default")
-    
+
     // Translate text from default domain
-    println(l.Get("Translate this"))
-    
+    fmt.Println(l.Get("Translate this"))
+
     // Load different domain
     l.AddDomain("translations")
-    
+
     // Translate text from domain
-    println(l.GetD("translations", "Translate this"))
+    fmt.Println(l.GetD("translations", "Translate this"))
 }
 ```
 
 This is also helpful for using inside templates (from the "text/template" package), where you can pass the Locale object to the template.
-If you set the Locale object as "Loc" in the template, then the template code would look like: 
+If you set the Locale object as "Loc" in the template, then the template code would look like:
 
 ```
 {{ .Loc.Get "Translate this" }}
@@ -228,11 +235,14 @@ If you set the Locale object as "Loc" in the template, then the template code wo
 
 ## Using the Po object to handle .po files and PO-formatted strings
 
-For when you need to work with PO files and strings, 
+For when you need to work with PO files and strings,
 you can directly use the Po object to parse it and access the translations in there in the same way.
 
 ```go
-import "github.com/leonelquinteros/gotext"
+import (
+    "fmt"
+    "git.deineagentur.com/DeineAgenturUG/gotext"
+)
 
 func main() {
     // Set PO content
@@ -246,12 +256,12 @@ msgstr ""
 msgid "One with var: %s"
 msgstr "This one sets the var: %s"
 `
-    
+
     // Create Po object
-    po := new(Po)
+    po := new(gotext.Po)
     po.Parse(str)
-    
-    println(po.Get("Translate this"))
+
+    fmt.Println(po.Get("Translate this"))
 }
 ```
 
@@ -262,10 +272,13 @@ PO format supports defining one or more plural forms for the same translation.
 Relying on the PO file headers, a Plural-Forms formula can be set on the translation file
 as defined in (https://www.gnu.org/savannah-checkouts/gnu/gettext/manual/html_node/Plural-forms.html)
 
-Plural formulas are parsed and evaluated using [Anko](https://github.com/mattn/anko)
+Plural formulas are parsed and evaluated using [Kinako](https://github.com/mattn/kinako)
 
 ```go
-import "github.com/leonelquinteros/gotext"
+import (
+    "fmt"
+    "git.deineagentur.com/DeineAgenturUG/gotext"
+)
 
 func main() {
     // Set PO content
@@ -287,21 +300,21 @@ msgid_plural "Several with vars: %s"
 msgstr[0] "This one is the singular: %s"
 msgstr[1] "This one is the plural: %s"
 `
-    
+
     // Create Po object
-    po := new(Po)
+    po := new(gotext.Po)
     po.Parse(str)
-    
-    println(po.GetN("One with var: %s", "Several with vars: %s", 54, v))
+
+    fmt.Println(po.GetN("One with var: %s", "Several with vars: %s", 54, v))
     // "This one is the plural: Variable"
 }
 ```
 
 
-# Contribute 
+# Contribute
 
 - Please, contribute.
 - Use the package on your projects.
-- Report issues on Github. 
+- Report issues on Github.
 - Send pull requests for bugfixes and improvements.
 - Send proposals on Github issues.

cli/xgotext/README.md

@@ -0,0 +1,48 @@
+# xgotext
+
+CLI tool to extract translation strings from Go packages into .POT files. 
+
+## Installation
+
+```
+go install git.deineagentur.com/DeineAgenturUG/gotext/cli/xgotext
+```
+
+## Usage
+
+```
+Usage of xgotext:
+  -default string
+        Name of default domain (default "default")
+  -exclude string
+        Comma separated list of directories to exclude (default ".git")
+  -in string
+        input dir: /path/to/go/pkg
+  -out string
+        output dir: /path/to/i18n/files
+```
+
+## Implementation
+
+This is the first (naive) implementation for this tool. 
+
+It will scan the Go package provided for method calls that matches the method names from the gotext package and write the corresponding translation files to the output directory. 
+
+Isn't able to parse calls to translation functions using parameters inside variables, if the translation string is inside a variable and that variable is used to invoke the translation function, this tool won't be able to parse that string. See this example code: 
+
+```go
+// This line will be added to the .po file
+gotext.Get("Translate this")
+
+tr := "Translate this string"
+// The following line will NOT be added to the .pot file
+gotext.Get(tr)
+```
+
+The CLI tool traverse sub-directories based on the given input directory.
+
+
+## Contribute
+
+Please
+

cli/xgotext/fixtures/i18n/default.po

@@ -0,0 +1,28 @@
+msgid ""
+msgstr ""
+"Plural-Forms: nplurals=2; plural=(n != 1);\n"
+"MIME-Version: 1.0\n"
+"Content-Type: text/plain; charset=UTF-8\n"
+"Content-Transfer-Encoding: 8bit\n"
+"Language: \n"
+"X-Generator: xgotext\n"
+
+	
+#: fixtures/main.go:23
+#. gotext.Get
+msgid "My text on 'domain-name' domain"
+msgstr ""
+
+#: fixtures/main.go:38
+#. l.GetN
+msgid "Singular"
+msgid_plural "Plural"
+msgstr[0] ""
+msgstr[1] ""
+
+#: fixtures/main.go:40
+#. l.GetN
+msgid "SingularVar"
+msgid_plural "PluralVar"
+msgstr[0] ""
+msgstr[1] ""

cli/xgotext/fixtures/i18n/domain.po

@@ -0,0 +1,15 @@
+msgid ""
+msgstr ""
+"Plural-Forms: nplurals=2; plural=(n != 1);\n"
+"MIME-Version: 1.0\n"
+"Content-Type: text/plain; charset=UTF-8\n"
+"Content-Transfer-Encoding: 8bit\n"
+"Language: \n"
+"X-Generator: xgotext\n"
+
+	
+#: fixtures/main.go:42
+#. l.GetDC
+msgctxt "ctx"
+msgid "string"
+msgstr ""

cli/xgotext/fixtures/i18n/domain2.po

@@ -0,0 +1,14 @@
+msgid ""
+msgstr ""
+"Plural-Forms: nplurals=2; plural=(n != 1);\n"
+"MIME-Version: 1.0\n"
+"Content-Type: text/plain; charset=UTF-8\n"
+"Content-Transfer-Encoding: 8bit\n"
+"Language: \n"
+"X-Generator: xgotext\n"
+
+	
+#: fixtures/main.go:26
+#. gotext.GetD
+msgid "Another text on a different domain"
+msgstr ""

cli/xgotext/fixtures/i18n/translations.po

@@ -0,0 +1,22 @@
+msgid ""
+msgstr ""
+"Plural-Forms: nplurals=2; plural=(n != 1);\n"
+"MIME-Version: 1.0\n"
+"Content-Type: text/plain; charset=UTF-8\n"
+"Content-Transfer-Encoding: 8bit\n"
+"Language: \n"
+"X-Generator: xgotext\n"
+
+	
+#: fixtures/main.go:35
+#. l.GetD
+msgid "Translate this"
+msgstr ""
+
+#: fixtures/main.go:43
+#. l.GetNDC
+msgctxt "NDC-CTX"
+msgid "ndc"
+msgid_plural "ndcs"
+msgstr[0] ""
+msgstr[1] ""

cli/xgotext/fixtures/main.go

@@ -0,0 +1,90 @@
+package main
+
+import (
+	"errors"
+	"fmt"
+
+	"git.deineagentur.com/DeineAgenturUG/gotext"
+	alias "git.deineagentur.com/DeineAgenturUG/gotext"
+	"git.deineagentur.com/DeineAgenturUG/gotext/cli/xgotext/fixtures/pkg"
+)
+
+// Fake object with methods similar to gotext
+type Fake struct {
+}
+
+// Get by id
+func (f Fake) Get(id int) int {
+	return 42
+}
+
+// Fake object with same methods as gotext
+type Fake2 struct {
+}
+
+// Get by str
+func (f Fake2) Get(s string) string {
+	return s
+}
+
+func main() {
+	// Configure package
+	gotext.Configure("/path/to/locales/root/dir", "en_UK", "domain-name")
+
+	// Translate text from default domain
+	fmt.Println(gotext.Get("My text on 'domain-name' domain"))
+	// same as before
+	fmt.Println(gotext.Get("My text on 'domain-name' domain"))
+
+	// unsupported function call
+	trStr := "some string to translate"
+	fmt.Println(gotext.Get(trStr))
+
+	// same with alias package name
+	fmt.Println(alias.Get("alias call"))
+
+	// Translate text from a different domain without reconfigure
+	fmt.Println(gotext.GetD("domain2", "Another text on a different domain"))
+
+	// Create Locale with library path and language code
+	l := gotext.NewLocale("/path/to/locales/root/dir", "es_UY")
+
+	// Load domain '/path/to/locales/root/dir/es_UY/default.po'
+	l.AddDomain("translations")
+	l.SetDomain("translations")
+
+	// Translate text from domain
+	fmt.Println(l.GetD("translations", "Translate this"))
+
+	// Get plural translations
+	l.GetN("Singular", "Plural", 4)
+	num := 17
+	l.GetN("SingularVar", "PluralVar", num)
+
+	l.GetDC("domain2", "string", "ctx")
+	l.GetNDC("translations", "ndc", "ndcs", 7, "NDC-CTX")
+
+	// try fake structs
+	f := Fake{}
+	f.Get(3)
+
+	f2 := Fake2{}
+	f2.Get("3")
+
+	// use translator of sub object
+	t := pkg.Translate{}
+	t.L.Get("translate package")
+	t.S.L.Get("translate sub package")
+
+	// redefine alias with fake struct
+	alias := Fake2{}
+	alias.Get("3")
+
+	err := errors.New("test")
+	fmt.Print(err.Error())
+}
+
+// dummy function
+func dummy(locale *gotext.Locale) {
+	locale.Get("inside dummy")
+}

cli/xgotext/fixtures/pkg/pkg.go

@@ -0,0 +1,16 @@
+package pkg
+
+import "git.deineagentur.com/DeineAgenturUG/gotext"
+
+type SubTranslate struct {
+	L gotext.Locale
+}
+
+type Translate struct {
+	L gotext.Locale
+	S SubTranslate
+}
+
+func test() {
+	gotext.Get("inside sub package")
+}

cli/xgotext/main.go

@@ -0,0 +1,45 @@
+package main
+
+import (
+	"flag"
+	"log"
+	"strings"
+
+	"git.deineagentur.com/DeineAgenturUG/gotext/cli/xgotext/parser"
+)
+
+var (
+	dirName       = flag.String("in", "", "input dir: /path/to/go/pkg")
+	outputDir     = flag.String("out", "", "output dir: /path/to/i18n/files")
+	defaultDomain = flag.String("default", "default", "Name of default domain")
+	excludeDirs   = flag.String("exclude", ".git", "Comma separated list of directories to exclude")
+	verbose       = flag.Bool("v", false, "print currently handled directory")
+)
+
+func main() {
+	flag.Parse()
+
+	// Init logger
+	log.SetFlags(0)
+
+	if *dirName == "" {
+		log.Fatal("No input directory given")
+	}
+	if *outputDir == "" {
+		log.Fatal("No output directory given")
+	}
+
+	data := &parser.DomainMap{
+		Default: *defaultDomain,
+	}
+
+	err := parser.ParseDirRec(*dirName, strings.Split(*excludeDirs, ","), data, *verbose)
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	err = data.Save(*outputDir)
+	if err != nil {
+		log.Fatal(err)
+	}
+}

cli/xgotext/parser/domain.go

@@ -0,0 +1,195 @@
+package parser
+
+import (
+	"fmt"
+	"os"
+	"path/filepath"
+	"sort"
+	"strings"
+)
+
+// Translation for a text to translate
+type Translation struct {
+	MsgId           string
+	MsgIdPlural     string
+	Context         string
+	SourceLocations []string
+}
+
+// AddLocations to translation
+func (t *Translation) AddLocations(locations []string) {
+	if t.SourceLocations == nil {
+		t.SourceLocations = locations
+	} else {
+		t.SourceLocations = append(t.SourceLocations, locations...)
+	}
+}
+
+// Dump translation as string
+func (t *Translation) Dump() string {
+	data := make([]string, 0, len(t.SourceLocations)+5)
+
+	for _, location := range t.SourceLocations {
+		data = append(data, "#: "+location)
+	}
+
+	if t.Context != "" {
+		data = append(data, "msgctxt "+t.Context)
+	}
+
+	data = append(data, "msgid "+t.MsgId)
+
+	if t.MsgIdPlural == "" {
+		data = append(data, "msgstr \"\"")
+	} else {
+		data = append(data,
+			"msgid_plural "+t.MsgIdPlural,
+			"msgstr[0] \"\"",
+			"msgstr[1] \"\"")
+	}
+
+	return strings.Join(data, "\n")
+}
+
+// TranslationMap contains a map of translations with the ID as key
+type TranslationMap map[string]*Translation
+
+// Dump the translation map as string
+func (m TranslationMap) Dump() string {
+	// sort by translation id for consistence output
+	keys := make([]string, 0, len(m))
+	for k := range m {
+		keys = append(keys, k)
+	}
+	sort.Strings(keys)
+
+	data := make([]string, 0, len(m))
+	for _, key := range keys {
+		data = append(data, (m)[key].Dump())
+	}
+	return strings.Join(data, "\n\n")
+}
+
+// Domain holds all translations of one domain
+type Domain struct {
+	Translations        TranslationMap
+	ContextTranslations map[string]TranslationMap
+}
+
+// AddTranslation to the domain
+func (d *Domain) AddTranslation(translation *Translation) {
+	if d.Translations == nil {
+		d.Translations = make(TranslationMap)
+		d.ContextTranslations = make(map[string]TranslationMap)
+	}
+
+	if translation.Context == "" {
+		if t, ok := d.Translations[translation.MsgId]; ok {
+			t.AddLocations(translation.SourceLocations)
+		} else {
+			d.Translations[translation.MsgId] = translation
+		}
+	} else {
+		if _, ok := d.ContextTranslations[translation.Context]; !ok {
+			d.ContextTranslations[translation.Context] = make(TranslationMap)
+		}
+
+		if t, ok := d.ContextTranslations[translation.Context][translation.MsgId]; ok {
+			t.AddLocations(translation.SourceLocations)
+		} else {
+			d.ContextTranslations[translation.Context][translation.MsgId] = translation
+		}
+	}
+}
+
+// Dump the domain as string
+func (d *Domain) Dump() string {
+	data := make([]string, 0, len(d.ContextTranslations)+1)
+	data = append(data, d.Translations.Dump())
+
+	// sort context translations by context for consistence output
+	keys := make([]string, 0, len(d.ContextTranslations))
+	for k := range d.ContextTranslations {
+		keys = append(keys, k)
+	}
+	sort.Strings(keys)
+
+	for _, key := range keys {
+		data = append(data, d.ContextTranslations[key].Dump())
+	}
+	return strings.Join(data, "\n\n")
+}
+
+// Save domain to file
+func (d *Domain) Save(path string) error {
+	file, err := os.Create(path)
+	if err != nil {
+		return fmt.Errorf("failed to domain: %v", err)
+	}
+	defer file.Close()
+
+	// write header
+	_, err = file.WriteString(`msgid ""
+msgstr ""
+"Plural-Forms: nplurals=2; plural=(n != 1);\n"
+"MIME-Version: 1.0\n"
+"Content-Type: text/plain; charset=UTF-8\n"
+"Content-Transfer-Encoding: 8bit\n"
+"Language: \n"
+"X-Generator: xgotext\n"
+
+`)
+	if err != nil {
+		return err
+	}
+
+	// write domain content
+	_, err = file.WriteString(d.Dump())
+	return err
+}
+
+// DomainMap contains multiple domains as map with name as key
+type DomainMap struct {
+	Domains map[string]*Domain
+	Default string
+}
+
+// AddTranslation to domain map
+func (m *DomainMap) AddTranslation(domain string, translation *Translation) {
+	if m.Domains == nil {
+		m.Domains = make(map[string]*Domain, 1)
+	}
+
+	// use "default" as default domain if not set
+	if m.Default == "" {
+		m.Default = "default"
+	}
+
+	// no domain given -> use default
+	if domain == "" {
+		domain = m.Default
+	}
+
+	if _, ok := m.Domains[domain]; !ok {
+		m.Domains[domain] = new(Domain)
+	}
+	m.Domains[domain].AddTranslation(translation)
+}
+
+// Save domains to directory
+func (m *DomainMap) Save(directory string) error {
+	// ensure output directory exist
+	err := os.MkdirAll(directory, os.ModePerm)
+	if err != nil {
+		return fmt.Errorf("failed to create output dir: %v", err)
+	}
+
+	// save each domain in a separate po file
+	for name, domain := range m.Domains {
+		err := domain.Save(filepath.Join(directory, name+".pot"))
+		if err != nil {
+			return fmt.Errorf("failed to save domain %s: %v", name, err)
+		}
+	}
+	return nil
+}

cli/xgotext/parser/golang.go

@@ -0,0 +1,271 @@
+package parser
+
+import (
+	"fmt"
+	"go/ast"
+	"go/token"
+	"go/types"
+	"log"
+	"path/filepath"
+	"strconv"
+
+	"golang.org/x/tools/go/packages"
+)
+
+// GetterDef describes a getter
+type GetterDef struct {
+	Id      int
+	Plural  int
+	Context int
+	Domain  int
+}
+
+// maxArgIndex returns the largest argument index
+func (d *GetterDef) maxArgIndex() int {
+	m := d.Id
+	if d.Plural > m {
+		m = d.Plural
+	}
+	if d.Context > m {
+		m = d.Context
+	}
+	if d.Domain > m {
+		m = d.Domain
+	}
+	return m
+}
+
+// list of supported getter
+var gotextGetter = map[string]GetterDef{
+	"Get":    {0, -1, -1, -1},
+	"GetN":   {0, 1, -1, -1},
+	"GetD":   {1, -1, -1, 0},
+	"GetND":  {1, 2, -1, 0},
+	"GetC":   {0, -1, 1, -1},
+	"GetNC":  {0, 1, 3, -1},
+	"GetDC":  {1, -1, 2, 0},
+	"GetNDC": {1, 2, 4, 0},
+}
+
+// register go parser
+func init() {
+	AddParser(goParser)
+}
+
+// parse go package
+func goParser(dirPath, basePath string, data *DomainMap) error {
+	fileSet := token.NewFileSet()
+
+	conf := packages.Config{
+		Mode: packages.NeedName |
+			packages.NeedFiles |
+			packages.NeedSyntax |
+			packages.NeedTypes |
+			packages.NeedTypesInfo,
+		Fset: fileSet,
+		Dir:  basePath,
+	}
+
+	// load package from path
+	pkgs, err := packages.Load(&packages.Config{
+		Mode: conf.Mode,
+		Fset: fileSet,
+		Dir:  dirPath,
+	})
+	if err != nil || len(pkgs) == 0 {
+		// not a go package
+		return nil
+	}
+
+	// handle each file
+	for _, node := range pkgs[0].Syntax {
+		file := GoFile{
+			pkgConf:  &conf,
+			filePath: fileSet.Position(node.Package).Filename,
+			basePath: basePath,
+			data:     data,
+			fileSet:  fileSet,
+
+			importedPackages: map[string]*packages.Package{
+				pkgs[0].Name: pkgs[0],
+			},
+		}
+
+		ast.Inspect(node, file.inspectFile)
+	}
+	return nil
+}
+
+// GoFile handles the parsing of one go file
+type GoFile struct {
+	filePath string
+	basePath string
+	data     *DomainMap
+
+	fileSet *token.FileSet
+	pkgConf *packages.Config
+
+	importedPackages map[string]*packages.Package
+}
+
+// getPackage loads module by name
+func (g *GoFile) getPackage(name string) (*packages.Package, error) {
+	pkgs, err := packages.Load(g.pkgConf, name)
+	if err != nil {
+		return nil, err
+	}
+	if len(pkgs) == 0 {
+		return nil, nil
+	}
+	return pkgs[0], nil
+}
+
+// getType from ident object
+func (g *GoFile) getType(ident *ast.Ident) types.Object {
+	for _, pkg := range g.importedPackages {
+		if obj, ok := pkg.TypesInfo.Uses[ident]; ok {
+			return obj
+		}
+	}
+	return nil
+}
+
+func (g *GoFile) inspectFile(n ast.Node) bool {
+	switch x := n.(type) {
+	// get names of imported packages
+	case *ast.ImportSpec:
+		packageName, _ := strconv.Unquote(x.Path.Value)
+
+		pkg, err := g.getPackage(packageName)
+		if err != nil {
+			log.Printf("failed to load package %s: %s", packageName, err)
+		} else {
+			if x.Name == nil {
+				g.importedPackages[pkg.Name] = pkg
+			} else {
+				g.importedPackages[x.Name.Name] = pkg
+			}
+		}
+
+	// check each function call
+	case *ast.CallExpr:
+		g.inspectCallExpr(x)
+
+	default:
+		print()
+	}
+
+	return true
+}
+
+// checkType for gotext object
+func (g *GoFile) checkType(rawType types.Type) bool {
+	switch t := rawType.(type) {
+	case *types.Pointer:
+		return g.checkType(t.Elem())
+
+	case *types.Named:
+		if t.Obj().Pkg() == nil || t.Obj().Pkg().Path() != "git.deineagentur.com/DeineAgenturUG/gotext" {
+			return false
+		}
+	default:
+		return false
+	}
+	return true
+}
+
+func (g *GoFile) inspectCallExpr(n *ast.CallExpr) {
+	// must be a selector expression otherwise it is a local function call
+	expr, ok := n.Fun.(*ast.SelectorExpr)
+	if !ok {
+		return
+	}
+
+	switch e := expr.X.(type) {
+	// direct call
+	case *ast.Ident:
+		// object is a package if the Obj is not set
+		if e.Obj == nil {
+			pkg, ok := g.importedPackages[e.Name]
+			if !ok || pkg.PkgPath != "git.deineagentur.com/DeineAgenturUG/gotext" {
+				return
+			}
+
+		} else {
+			// validate type of object
+			t := g.getType(e)
+			if t == nil || !g.checkType(t.Type()) {
+				return
+			}
+		}
+
+	// call to attribute
+	case *ast.SelectorExpr:
+		// validate type of object
+		t := g.getType(e.Sel)
+		if t == nil || !g.checkType(t.Type()) {
+			return
+		}
+
+	default:
+		return
+	}
+
+	// convert args
+	args := make([]*ast.BasicLit, len(n.Args))
+	for idx, arg := range n.Args {
+		args[idx], _ = arg.(*ast.BasicLit)
+	}
+
+	// get position
+	path, _ := filepath.Rel(g.basePath, g.filePath)
+	position := fmt.Sprintf("%s:%d", path, g.fileSet.Position(n.Lparen).Line)
+
+	// handle getters
+	if def, ok := gotextGetter[expr.Sel.String()]; ok {
+		g.parseGetter(def, args, position)
+		return
+	}
+}
+
+func (g *GoFile) parseGetter(def GetterDef, args []*ast.BasicLit, pos string) {
+	// check if enough arguments are given
+	if len(args) < def.maxArgIndex() {
+		return
+	}
+
+	// get domain
+	var domain string
+	if def.Domain != -1 {
+		domain, _ = strconv.Unquote(args[def.Domain].Value)
+	}
+
+	// only handle function calls with strings as ID
+	if args[def.Id] == nil || args[def.Id].Kind != token.STRING {
+		log.Printf("ERR: Unsupported call at %s (ID not a string)", pos)
+		return
+	}
+
+	trans := Translation{
+		MsgId:           args[def.Id].Value,
+		SourceLocations: []string{pos},
+	}
+	if def.Plural > 0 {
+		// plural ID must be a string
+		if args[def.Plural] == nil || args[def.Plural].Kind != token.STRING {
+			log.Printf("ERR: Unsupported call at %s (Plural not a string)", pos)
+			return
+		}
+		trans.MsgIdPlural = args[def.Plural].Value
+	}
+	if def.Context > 0 {
+		// Context must be a string
+		if args[def.Context] == nil || args[def.Context].Kind != token.STRING {
+			log.Printf("ERR: Unsupported call at %s (Context not a string)", pos)
+			return
+		}
+		trans.Context = args[def.Context].Value
+	}
+
+	g.data.AddTranslation(domain, &trans)
+}

cli/xgotext/parser/parser.go

@@ -0,0 +1,67 @@
+package parser
+
+import (
+	"log"
+	"os"
+	"path/filepath"
+	"strings"
+)
+
+// ParseDirFunc parses one directory
+type ParseDirFunc func(filePath, basePath string, data *DomainMap) error
+
+var knownParser []ParseDirFunc
+
+// AddParser to the known parser list
+func AddParser(parser ParseDirFunc) {
+	if knownParser == nil {
+		knownParser = []ParseDirFunc{parser}
+	} else {
+		knownParser = append(knownParser, parser)
+	}
+}
+
+// ParseDir calls all known parser for each directory
+func ParseDir(dirPath, basePath string, data *DomainMap) error {
+	dirPath, _ = filepath.Abs(dirPath)
+	basePath, _ = filepath.Abs(basePath)
+
+	for _, parser := range knownParser {
+		err := parser(dirPath, basePath, data)
+		if err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+// ParseDirRec calls all known parser for each directory
+func ParseDirRec(dirPath string, exclude []string, data *DomainMap, verbose bool) error {
+	dirPath, _ = filepath.Abs(dirPath)
+
+	err := filepath.Walk(dirPath, func(path string, info os.FileInfo, err error) error {
+		if err != nil {
+			return err
+		}
+
+		if info.IsDir() {
+			// skip directory if in exclude list
+			subDir, _ := filepath.Rel(dirPath, path)
+			for _, d := range exclude {
+				if strings.HasPrefix(subDir, d) {
+					return nil
+				}
+			}
+			if verbose {
+				log.Print(path)
+			}
+
+			err := ParseDir(path, dirPath, data)
+			if err != nil {
+				return err
+			}
+		}
+		return nil
+	})
+	return err
+}

fixtures/ar/categories.po

@@ -0,0 +1,19 @@
+msgid ""
+msgstr ""
+"Plural-Forms: nplurals=6; plural=(n==0 ? 0 : n==1 ? 1 : n==2 ? 2 : n%100>=3 && n%100<=10 ? 3 : n%100>=11 && n%100<=99 ? 4 : 5);\n"
+
+msgid "Alcohol & Tobacco"
+msgstr "الكحول والتبغ"
+
+# this test data is purposely missing msgstr
+msgid "%d selected"
+msgid_plural "%d selected"
+
+msgid "Load %d more document"
+msgid_plural "Load %d more documents"
+msgstr[0] "حمّل %d مستندات إضافيّة"
+msgstr[1] "حمّل مستند واحد إضافي"
+msgstr[2] "حمّل مستندين إضافيين"
+msgstr[3] "حمّل %d مستندات إضافيّة"
+msgstr[4] "حمّل %d مستندا إضافيّا"
+msgstr[5] "حمّل %d مستند إضافي"

fixtures/ar/no_plural_header.po

@@ -0,0 +1,2 @@
+msgid "Alcohol & Tobacco"
+msgstr "الكحول والتبغ"

fixtures/de/default.po

@@ -0,0 +1,77 @@
+msgid ""
+msgstr ""
+"Plural-Forms: nplurals=2; plural=(n != 1);\n"
+"Project-Id-Version: \n"
+"POT-Creation-Date: \n"
+"PO-Revision-Date: \n"
+"Last-Translator: Josef Fröhle <froehle@b1-systems.de>\n"
+"Language-Team: \n"
+"MIME-Version: 1.0\n"
+"Content-Type: text/plain; charset=UTF-8\n"
+"Content-Transfer-Encoding: 8bit\n"
+"Language: de\n"
+"X-Generator: Poedit 2.0.6\n"
+"X-Poedit-SourceCharset: UTF-8\n"
+
+# Initial comment
+# Headers below
+msgid "language"
+msgstr "de"
+
+# Some comment
+msgid "My text"
+msgstr "Translated text"
+
+# More comments
+msgid "Another string"
+msgstr ""
+
+# Multi-line msgid
+msgid ""
+"multi\n"
+"line\n"
+"id"
+msgstr "id with multiline content"
+
+# Multi-line msgid_plural
+msgid ""
+"multi\n"
+"line\n"
+"plural\n"
+"id"
+msgstr "plural id with multiline content"
+
+# Multi-line string
+msgid "Multi-line"
+msgstr ""
+"Multi \n"
+"line"
+
+msgid "One with var: %s"
+msgid_plural "Several with vars: %s"
+msgstr[0] "This one is the singular: %s"
+msgstr[1] "This one is the plural: %s"
+
+msgctxt "Ctx"
+msgid "One with var: %s"
+msgid_plural "Several with vars: %s"
+msgstr[0] "This one is the singular in a Ctx context: %s"
+msgstr[1] "This one is the plural in a Ctx context: %s"
+
+msgid "Some random"
+msgstr "Some random translation"
+
+msgctxt "Ctx"
+msgid "Some random in a context"
+msgstr "Some random translation in a context"
+
+msgid "Empty translation"
+msgstr ""
+
+msgid "Empty plural form singular"
+msgid_plural "Empty plural form"
+msgstr[0] "Singular translated"
+msgstr[1] ""
+
+msgid "More"
+msgstr "More translation"

fixtures/de_DE/LC_MESSAGES/default.po

@@ -0,0 +1,77 @@
+msgid ""
+msgstr ""
+"Plural-Forms: nplurals=2; plural=(n != 1);\n"
+"Project-Id-Version: \n"
+"POT-Creation-Date: \n"
+"PO-Revision-Date: \n"
+"Last-Translator: Josef Fröhle <froehle@b1-systems.de>\n"
+"Language-Team: \n"
+"MIME-Version: 1.0\n"
+"Content-Type: text/plain; charset=UTF-8\n"
+"Content-Transfer-Encoding: 8bit\n"
+"Language: de_DE\n"
+"X-Generator: Poedit 2.0.6\n"
+"X-Poedit-SourceCharset: UTF-8\n"
+
+# Initial comment
+# Headers below
+msgid "language"
+msgstr "de_DE"
+
+# Some comment
+msgid "My text"
+msgstr "Translated text"
+
+# More comments
+msgid "Another string"
+msgstr ""
+
+# Multi-line msgid
+msgid ""
+"multi\n"
+"line\n"
+"id"
+msgstr "id with multiline content"
+
+# Multi-line msgid_plural
+msgid ""
+"multi\n"
+"line\n"
+"plural\n"
+"id"
+msgstr "plural id with multiline content"
+
+# Multi-line string
+msgid "Multi-line"
+msgstr ""
+"Multi \n"
+"line"
+
+msgid "One with var: %s"
+msgid_plural "Several with vars: %s"
+msgstr[0] "This one is the singular: %s"
+msgstr[1] "This one is the plural: %s"
+
+msgctxt "Ctx"
+msgid "One with var: %s"
+msgid_plural "Several with vars: %s"
+msgstr[0] "This one is the singular in a Ctx context: %s"
+msgstr[1] "This one is the plural in a Ctx context: %s"
+
+msgid "Some random"
+msgstr "Some random translation"
+
+msgctxt "Ctx"
+msgid "Some random in a context"
+msgstr "Some random translation in a context"
+
+msgid "Empty translation"
+msgstr ""
+
+msgid "Empty plural form singular"
+msgid_plural "Empty plural form"
+msgstr[0] "Singular translated"
+msgstr[1] ""
+
+msgid "More"
+msgstr "More translation"

fixtures/en_AU/default.po

@@ -0,0 +1,68 @@
+msgid ""
+msgstr ""
+"Plural-Forms: nplurals=2; plural=(n != 1);\n"
+"Project-Id-Version: \n"
+"POT-Creation-Date: \n"
+"PO-Revision-Date: \n"
+"Last-Translator: Josef Fröhle <froehle@b1-systems.de>\n"
+"Language-Team: \n"
+"MIME-Version: 1.0\n"
+"Content-Type: text/plain; charset=UTF-8\n"
+"Content-Transfer-Encoding: 8bit\n"
+"Language: en_US\n"
+"X-Generator: Poedit 2.0.6\n"
+"X-Poedit-SourceCharset: UTF-8\n"
+
+# Initial comment
+# Headers below
+msgid "language"
+msgstr "en_AU"
+
+# Some comment
+msgid "My text"
+msgstr "Translated text"
+
+# More comments
+msgid "Another string"
+msgstr ""
+
+# Multi-line msgid
+msgid "multilineid"
+msgstr "id with multiline content"
+
+# Multi-line msgid_plural
+msgid "multilinepluralid"
+msgstr "plural id with multiline content"
+
+# Multi-line string
+msgid "Multi-line"
+msgstr "Multi line"
+
+msgid "One with var: %s"
+msgid_plural "Several with vars: %s"
+msgstr[0] "This one is the singular: %s"
+msgstr[1] "This one is the plural: %s"
+
+msgctxt "Ctx"
+msgid "One with var: %s"
+msgid_plural "Several with vars: %s"
+msgstr[0] "This one is the singular in a Ctx context: %s"
+msgstr[1] "This one is the plural in a Ctx context: %s"
+
+msgid "Some random"
+msgstr "Some random translation"
+
+msgctxt "Ctx"
+msgid "Some random in a context"
+msgstr "Some random translation in a context"
+
+msgid "Empty translation"
+msgstr ""
+
+msgid "Empty plural form singular"
+msgid_plural "Empty plural form"
+msgstr[0] "Singular translated"
+msgstr[1] ""
+
+msgid "More"
+msgstr "More translation"

fixtures/en_US/default.po

@@ -0,0 +1,68 @@
+msgid ""
+msgstr ""
+"Plural-Forms: nplurals=2; plural=(n != 1);\n"
+"Project-Id-Version: \n"
+"POT-Creation-Date: \n"
+"PO-Revision-Date: \n"
+"Last-Translator: Josef Fröhle <froehle@b1-systems.de>\n"
+"Language-Team: \n"
+"MIME-Version: 1.0\n"
+"Content-Type: text/plain; charset=UTF-8\n"
+"Content-Transfer-Encoding: 8bit\n"
+"Language: en_US\n"
+"X-Generator: Poedit 2.0.6\n"
+"X-Poedit-SourceCharset: UTF-8\n"
+
+# Initial comment
+# Headers below
+msgid "language"
+msgstr "en_US"
+
+# Some comment
+msgid "My text"
+msgstr "Translated text"
+
+# More comments
+msgid "Another string"
+msgstr ""
+
+# Multi-line msgid
+msgid "multilineid"
+msgstr "id with multiline content"
+
+# Multi-line msgid_plural
+msgid "multilinepluralid"
+msgstr "plural id with multiline content"
+
+# Multi-line string
+msgid "Multi-line"
+msgstr "Multi line"
+
+msgid "One with var: %s"
+msgid_plural "Several with vars: %s"
+msgstr[0] "This one is the singular: %s"
+msgstr[1] "This one is the plural: %s"
+
+msgctxt "Ctx"
+msgid "One with var: %s"
+msgid_plural "Several with vars: %s"
+msgstr[0] "This one is the singular in a Ctx context: %s"
+msgstr[1] "This one is the plural in a Ctx context: %s"
+
+msgid "Some random"
+msgstr "Some random translation"
+
+msgctxt "Ctx"
+msgid "Some random in a context"
+msgstr "Some random translation in a context"
+
+msgid "Empty translation"
+msgstr ""
+
+msgid "Empty plural form singular"
+msgid_plural "Empty plural form"
+msgstr[0] "Singular translated"
+msgstr[1] ""
+
+msgid "More"
+msgstr "More translation"

fixtures/fr/LC_MESSAGES/default.po

@@ -0,0 +1,77 @@
+msgid ""
+msgstr ""
+"Plural-Forms: nplurals=2; plural=(n > 1);\n"
+"Project-Id-Version: \n"
+"POT-Creation-Date: \n"
+"PO-Revision-Date: \n"
+"Last-Translator: Josef Fröhle <froehle@b1-systems.de>\n"
+"Language-Team: \n"
+"MIME-Version: 1.0\n"
+"Content-Type: text/plain; charset=UTF-8\n"
+"Content-Transfer-Encoding: 8bit\n"
+"Language: fr\n"
+"X-Generator: Poedit 2.0.6\n"
+"X-Poedit-SourceCharset: UTF-8\n"
+
+# Initial comment
+# Headers below
+msgid "language"
+msgstr "fr"
+
+# Some comment
+msgid "My text"
+msgstr "Translated text"
+
+# More comments
+msgid "Another string"
+msgstr ""
+
+# Multi-line msgid
+msgid ""
+"multi\n"
+"line\n"
+"id"
+msgstr "id with multiline content"
+
+# Multi-line msgid_plural
+msgid ""
+"multi\n"
+"line\n"
+"plural\n"
+"id"
+msgstr "plural id with multiline content"
+
+# Multi-line string
+msgid "Multi-line"
+msgstr ""
+"Multi \n"
+"line"
+
+msgid "One with var: %s"
+msgid_plural "Several with vars: %s"
+msgstr[0] "This one is the singular: %s"
+msgstr[1] "This one is the plural: %s"
+
+msgctxt "Ctx"
+msgid "One with var: %s"
+msgid_plural "Several with vars: %s"
+msgstr[0] "This one is the singular in a Ctx context: %s"
+msgstr[1] "This one is the plural in a Ctx context: %s"
+
+msgid "Some random"
+msgstr "Some random translation"
+
+msgctxt "Ctx"
+msgid "Some random in a context"
+msgstr "Some random translation in a context"
+
+msgid "Empty translation"
+msgstr ""
+
+msgid "Empty plural form singular"
+msgid_plural "Empty plural form"
+msgstr[0] "Singular translated"
+msgstr[1] ""
+
+msgid "More"
+msgstr "More translation"

go.mod

@@ -0,0 +1,7 @@
+module git.deineagentur.com/DeineAgenturUG/gotext
+
+// go: no requirements found in Gopkg.lock
+
+require golang.org/x/tools v0.0.0-20200221224223-e1da425f72fd
+
+go 1.13

go.sum

@@ -0,0 +1,14 @@
+golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
+golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
+golang.org/x/mod v0.1.1-0.20191105210325-c90efee705ee h1:WG0RUwxtNT4qqaXX3DPA8zHFNm/D9xaBpxzHt1WcA/E=
+golang.org/x/mod v0.1.1-0.20191105210325-c90efee705ee/go.mod h1:QqPTAvyqsEbceGzBzNggFXnrqF1CaUcvgkdR5Ot7KZg=
+golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
+golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
+golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
+golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
+golang.org/x/tools v0.0.0-20200221224223-e1da425f72fd h1:hHkvGJK23seRCflePJnVa9IMv8fsuavSCWKd11kDQFs=
+golang.org/x/tools v0.0.0-20200221224223-e1da425f72fd/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=
+golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898 h1:/atklqdjdhuosWIl6AIbOeHJjicWYPqR9bpxqxYG2pA=
+golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=

gotext.go

@@ -1,151 +1,247 @@
 /*
-Package gotext implements GNU gettext utilities.
+ Package gotext implements GNU gettext utilities.
 
-For quick/simple translations you can use the package level functions directly.
+ For quick/simple translations you can use the package level functions directly.
 
-    import "github.com/leonelquinteros/gotext"
+     import (
+ 	    "fmt"
+ 	    "git.deineagentur.com/DeineAgenturUG/gotext"
+     )
 
-    func main() {
-        // Configure package
-        gotext.Configure("/path/to/locales/root/dir", "en_UK", "domain-name")
+     func main() {
+         // Configure package
+         gotext.Configure("/path/to/locales/root/dir", "en_UK", "domain-name")
 
-        // Translate text from default domain
-        println(gotext.Get("My text on 'domain-name' domain"))
+         // Translate text from default domain
+         fmt.Println(gotext.Get("My text on 'domain-name' domain"))
 
-        // Translate text from a different domain without reconfigure
-        println(gotext.GetD("domain2", "Another text on a different domain"))
-    }
+         // Translate text from a different domain without reconfigure
+         fmt.Println(gotext.GetD("domain2", "Another text on a different domain"))
+     }
 
 */
 package gotext
 
+import (
+	"encoding/gob"
+	"sync"
+)
+
 // Global environment variables
-var (
+type config struct {
+	sync.RWMutex
+
 	// Default domain to look at when no domain is specified. Used by package level functions.
-	domain = "default"
+	domain string
 
 	// Language set.
-	language = "en_US"
+	language string
 
-	// Path to library directory where all locale directories and translation files are.
-	library = "/usr/local/share/locale"
+	// Path to library directory where all locale directories and Translation files are.
+	library string
 
 	// Storage for package level methods
 	storage *Locale
-)
+}
+
+var globalConfig *config
+
+func init() {
+	// Init default configuration
+	globalConfig = &config{
+		domain:   "default",
+		language: "en_US",
+		library:  "/usr/local/share/locale",
+		storage:  nil,
+	}
+
+	// Register Translator types for gob encoding
+	gob.Register(TranslatorEncoding{})
+}
 
 // loadStorage creates a new Locale object at package level based on the Global variables settings.
 // It's called automatically when trying to use Get or GetD methods.
 func loadStorage(force bool) {
-	if storage == nil || force {
-		storage = NewLocale(library, language)
+	globalConfig.Lock()
+
+	if globalConfig.storage == nil || force {
+		globalConfig.storage = NewLocale(globalConfig.library, globalConfig.language)
 	}
 
-	if _, ok := storage.domains[domain]; !ok || force {
-		storage.AddDomain(domain)
+	if _, ok := globalConfig.storage.Domains[globalConfig.domain]; !ok || force {
+		globalConfig.storage.AddDomain(globalConfig.domain)
 	}
+	globalConfig.storage.SetDomain(globalConfig.domain)
+
+	globalConfig.Unlock()
 }
 
 // GetDomain is the domain getter for the package configuration
 func GetDomain() string {
-	return domain
+	var dom string
+	globalConfig.RLock()
+	if globalConfig.storage != nil {
+		dom = globalConfig.storage.GetDomain()
+	}
+	if dom == "" {
+		dom = globalConfig.domain
+	}
+	globalConfig.RUnlock()
+
+	return dom
 }
 
 // SetDomain sets the name for the domain to be used at package level.
-// It reloads the corresponding translation file.
+// It reloads the corresponding Translation file.
 func SetDomain(dom string) {
-	domain = dom
+	globalConfig.Lock()
+	globalConfig.domain = dom
+	if globalConfig.storage != nil {
+		globalConfig.storage.SetDomain(dom)
+	}
+	globalConfig.Unlock()
+
 	loadStorage(true)
 }
 
 // GetLanguage is the language getter for the package configuration
 func GetLanguage() string {
-	return language
+	globalConfig.RLock()
+	lang := globalConfig.language
+	globalConfig.RUnlock()
+
+	return lang
 }
 
 // SetLanguage sets the language code to be used at package level.
-// It reloads the corresponding translation file.
+// It reloads the corresponding Translation file.
 func SetLanguage(lang string) {
-	language = lang
+	globalConfig.Lock()
+	globalConfig.language = SimplifiedLocale(lang)
+	globalConfig.Unlock()
+
 	loadStorage(true)
 }
 
 // GetLibrary is the library getter for the package configuration
 func GetLibrary() string {
-	return library
+	globalConfig.RLock()
+	lib := globalConfig.library
+	globalConfig.RUnlock()
+
+	return lib
 }
 
 // SetLibrary sets the root path for the loale directories and files to be used at package level.
-// It reloads the corresponding translation file.
+// It reloads the corresponding Translation file.
 func SetLibrary(lib string) {
-	library = lib
+	globalConfig.Lock()
+	globalConfig.library = lib
+	globalConfig.Unlock()
+
 	loadStorage(true)
 }
 
-// Configure sets all configuration variables to be used at package level and reloads the corresponding translation file.
+// Configure sets all configuration variables to be used at package level and reloads the corresponding Translation file.
 // It receives the library path, language code and domain name.
 // This function is recommended to be used when changing more than one setting,
-// as using each setter will introduce a I/O overhead because the translation file will be loaded after each set.
+// as using each setter will introduce a I/O overhead because the Translation file will be loaded after each set.
 func Configure(lib, lang, dom string) {
-	library = lib
-	language = lang
-	domain = dom
+	globalConfig.Lock()
+	globalConfig.library = lib
+	globalConfig.language = SimplifiedLocale(lang)
+	globalConfig.domain = dom
+	globalConfig.Unlock()
 
 	loadStorage(true)
 }
 
-// Get uses the default domain globally set to return the corresponding translation of a given string.
+// Get uses the default domain globally set to return the corresponding Translation of a given string.
 // Supports optional parameters (vars... interface{}) to be inserted on the formatted string using the fmt.Printf syntax.
 func Get(str string, vars ...interface{}) string {
-	return GetD(domain, str, vars...)
+	return GetD(GetDomain(), str, vars...)
 }
 
-// GetN retrieves the (N)th plural form of translation for the given string in the "default" domain.
+// GetN retrieves the (N)th plural form of Translation for the given string in the default domain.
 // Supports optional parameters (vars... interface{}) to be inserted on the formatted string using the fmt.Printf syntax.
 func GetN(str, plural string, n int, vars ...interface{}) string {
-	return GetND("default", str, plural, n, vars...)
+	return GetND(GetDomain(), str, plural, n, vars...)
 }
 
-// GetD returns the corresponding translation in the given domain for a given string.
+// GetD returns the corresponding Translation in the given domain for a given string.
 // Supports optional parameters (vars... interface{}) to be inserted on the formatted string using the fmt.Printf syntax.
 func GetD(dom, str string, vars ...interface{}) string {
-	return GetND(dom, str, str, 1, vars...)
+	// Try to load default package Locale storage
+	loadStorage(false)
+
+	// Return Translation
+	globalConfig.RLock()
+
+	if _, ok := globalConfig.storage.Domains[dom]; !ok {
+		globalConfig.storage.AddDomain(dom)
+	}
+
+	tr := globalConfig.storage.GetD(dom, str, vars...)
+	globalConfig.RUnlock()
+
+	return tr
 }
 
-// GetND retrieves the (N)th plural form of translation in the given domain for a given string.
+// GetND retrieves the (N)th plural form of Translation in the given domain for a given string.
 // Supports optional parameters (vars... interface{}) to be inserted on the formatted string using the fmt.Printf syntax.
 func GetND(dom, str, plural string, n int, vars ...interface{}) string {
 	// Try to load default package Locale storage
 	loadStorage(false)
 
-	// Return translation
-	return storage.GetND(dom, str, plural, n, vars...)
+	// Return Translation
+	globalConfig.RLock()
+
+	if _, ok := globalConfig.storage.Domains[dom]; !ok {
+		globalConfig.storage.AddDomain(dom)
+	}
+
+	tr := globalConfig.storage.GetND(dom, str, plural, n, vars...)
+	globalConfig.RUnlock()
+
+	return tr
 }
 
-// GetC uses the default domain globally set to return the corresponding translation of the given string in the given context.
+// GetC uses the default domain globally set to return the corresponding Translation of the given string in the given context.
 // Supports optional parameters (vars... interface{}) to be inserted on the formatted string using the fmt.Printf syntax.
 func GetC(str, ctx string, vars ...interface{}) string {
-	return GetDC(domain, str, ctx, vars...)
+	return GetDC(GetDomain(), str, ctx, vars...)
 }
 
-// GetNC retrieves the (N)th plural form of translation for the given string in the given context in the "default" domain.
+// GetNC retrieves the (N)th plural form of Translation for the given string in the given context in the default domain.
 // Supports optional parameters (vars... interface{}) to be inserted on the formatted string using the fmt.Printf syntax.
 func GetNC(str, plural string, n int, ctx string, vars ...interface{}) string {
-	return GetNDC("default", str, plural, n, ctx, vars...)
+	return GetNDC(GetDomain(), str, plural, n, ctx, vars...)
 }
 
-// GetDC returns the corresponding translation in the given domain for the given string in the given context.
+// GetDC returns the corresponding Translation in the given domain for the given string in the given context.
 // Supports optional parameters (vars... interface{}) to be inserted on the formatted string using the fmt.Printf syntax.
 func GetDC(dom, str, ctx string, vars ...interface{}) string {
-	return GetNDC(dom, str, str, 1, ctx, vars...)
+	// Try to load default package Locale storage
+	loadStorage(false)
+
+	// Return Translation
+	globalConfig.RLock()
+	tr := globalConfig.storage.GetDC(dom, str, ctx, vars...)
+	globalConfig.RUnlock()
+
+	return tr
 }
 
-// GetNDC retrieves the (N)th plural form of translation in the given domain for a given string.
+// GetNDC retrieves the (N)th plural form of Translation in the given domain for a given string.
 // Supports optional parameters (vars... interface{}) to be inserted on the formatted string using the fmt.Printf syntax.
 func GetNDC(dom, str, plural string, n int, ctx string, vars ...interface{}) string {
 	// Try to load default package Locale storage
 	loadStorage(false)
 
-	// Return translation
-	return storage.GetNDC(dom, str, plural, n, ctx, vars...)
+	// Return Translation
+	globalConfig.RLock()
+	tr := globalConfig.storage.GetNDC(dom, str, plural, n, ctx, vars...)
+	globalConfig.RUnlock()
+
+	return tr
 }

gotext_test.go

@@ -2,7 +2,8 @@ package gotext
 
 import (
 	"os"
-	"path"
+	"path/filepath"
+	"sync"
 	"testing"
 )
 
@@ -32,10 +33,12 @@ func TestGettersSetters(t *testing.T) {
 func TestPackageFunctions(t *testing.T) {
 	// Set PO content
 	str := `
-msgid ""
-msgstr ""
+msgid   ""
+msgstr  "Project-Id-Version: %s\n"
+        "Report-Msgid-Bugs-To: %s\n"
+        
 # Initial comment
-# Headers below
+# More Headers below
 "Language: en\n"
 "Content-Type: text/plain; charset=UTF-8\n"
 "Content-Transfer-Encoding: 8bit\n"
@@ -55,14 +58,6 @@ msgstr[0] "This one is the singular: %s"
 msgstr[1] "This one is the plural: %s"
 msgstr[2] "And this is the second plural form: %s"
 
-msgid "This one has invalid syntax translations"
-msgid_plural "Plural index"
-msgstr[abc] "Wrong index"
-msgstr[1 "Forgot to close brackets"
-msgstr[0] "Badly formatted string'
-
-msgid "Invalid formatted id[] with no translations
-
 msgctxt "Ctx"
 msgid "One with var: %s"
 msgid_plural "Several with vars: %s"
@@ -70,38 +65,74 @@ msgstr[0] "This one is the singular in a Ctx context: %s"
 msgstr[1] "This one is the plural in a Ctx context: %s"
 
 msgid "Some random"
-msgstr "Some random translation"
+msgstr "Some random Translation"
 
 msgctxt "Ctx"
 msgid "Some random in a context"
-msgstr "Some random translation in a context"
+msgstr "Some random Translation in a context"
 
 msgid "More"
-msgstr "More translation"
+msgstr "More Translation"
 
-    `
+msgid "Untranslated"
+msgid_plural "Several untranslated"
+msgstr[0] ""
+msgstr[1] ""
+
+	`
+
+	anotherStr := `
+msgid   ""
+msgstr  "Project-Id-Version: %s\n"
+        "Report-Msgid-Bugs-To: %s\n"
+
+# Initial comment
+# More Headers below
+"Language: en\n"
+"Content-Type: text/plain; charset=UTF-8\n"
+"Content-Transfer-Encoding: 8bit\n"
+"Plural-Forms: nplurals=2; plural=(n != 1);\n"
+
+msgid "Another text on a different domain"
+msgstr "Another text on another domain"
+  `
 
 	// Create Locales directory on default location
-	dirname := path.Clean("/tmp" + string(os.PathSeparator) + "en_US")
+	dirname := filepath.Join("/tmp", "en_US")
 	err := os.MkdirAll(dirname, os.ModePerm)
 	if err != nil {
 		t.Fatalf("Can't create test directory: %s", err.Error())
 	}
 
 	// Write PO content to default domain file
-	filename := path.Clean(dirname + string(os.PathSeparator) + "default.po")
+	filename := filepath.Join(dirname, "default.po")
 
 	f, err := os.Create(filename)
 	if err != nil {
 		t.Fatalf("Can't create test file: %s", err.Error())
 	}
-	defer f.Close()
 
 	_, err = f.WriteString(str)
 	if err != nil {
 		t.Fatalf("Can't write to test file: %s", err.Error())
 	}
 
+	anotherFilename := filepath.Join(dirname, "another.po")
+
+	af, err := os.Create(anotherFilename)
+	if err != nil {
+		t.Fatalf("Can't create test file: %s", err.Error())
+	}
+
+	_, err = af.WriteString(anotherStr)
+	if err != nil {
+		t.Fatalf("Can't write to test file: %s", err.Error())
+	}
+
+	// Move file close to write the file, so we can use it in the next step
+	f.Close()
+	af.Close()
+
 	// Set package configuration
 	Configure("/tmp", "en_US", "default")
 
@@ -125,8 +156,8 @@ msgstr "More translation"
 
 	// Test context translations
 	tr = GetC("Some random in a context", "Ctx")
-	if tr != "Some random translation in a context" {
-		t.Errorf("Expected 'Some random translation in a context' but got '%s'", tr)
+	if tr != "Some random Translation in a context" {
+		t.Errorf("Expected 'Some random Translation in a context' but got '%s'", tr)
 	}
 
 	v = "Variable"
@@ -139,6 +170,218 @@ msgstr "More translation"
 	if tr != "This one is the plural in a Ctx context: Variable" {
 		t.Errorf("Expected 'This one is the plural in a Ctx context: Variable' but got '%s'", tr)
 	}
+
+	tr = GetD("another", "Another text on a different domain")
+	if tr != "Another text on another domain" {
+		t.Errorf("Expected 'Another text on another domain' but got '%s'", tr)
+	}
+}
+
+func TestUntranslated(t *testing.T) {
+	// Set PO content
+	str := `
+msgid ""
+msgstr ""
+# Initial comment
+# Headers below
+"Language: en\n"
+"Content-Type: text/plain; charset=UTF-8\n"
+"Content-Transfer-Encoding: 8bit\n"
+"Plural-Forms: nplurals=2; plural=(n != 1);\n"
+
+msgid "Untranslated"
+msgid_plural "Several untranslated"
+msgstr[0] ""
+msgstr[1] ""
+
+	`
+
+	// Create Locales directory on default location
+	dirname := filepath.Join("/tmp", "en_US")
+	err := os.MkdirAll(dirname, os.ModePerm)
+	if err != nil {
+		t.Fatalf("Can't create test directory: %s", err.Error())
+	}
+
+	// Write PO content to default domain file
+	filename := filepath.Join(dirname, "default.po")
+
+	f, err := os.Create(filename)
+	if err != nil {
+		t.Fatalf("Can't create test file: %s", err.Error())
+	}
+	defer f.Close()
+
+	_, err = f.WriteString(str)
+	if err != nil {
+		t.Fatalf("Can't write to test file: %s", err.Error())
+	}
+
+	// Set package configuration
+	Configure("/tmp", "en_US", "default")
+
+	// Test untranslated
+	tr := Get("Untranslated")
+	if tr != "Untranslated" {
+		t.Errorf("Expected 'Untranslated' but got '%s'", tr)
+	}
+	tr = GetN("Untranslated", "Several untranslated", 1)
+	if tr != "Untranslated" {
+		t.Errorf("Expected 'Untranslated' but got '%s'", tr)
+	}
+
+	tr = GetN("Untranslated", "Several untranslated", 2)
+	if tr != "Several untranslated" {
+		t.Errorf("Expected 'Several untranslated' but got '%s'", tr)
+	}
+
+	tr = GetD("default", "Untranslated")
+	if tr != "Untranslated" {
+		t.Errorf("Expected 'Untranslated' but got '%s'", tr)
+	}
+	tr = GetND("default", "Untranslated", "Several untranslated", 1)
+	if tr != "Untranslated" {
+		t.Errorf("Expected 'Untranslated' but got '%s'", tr)
+	}
+
+	tr = GetND("default", "Untranslated", "Several untranslated", 2)
+	if tr != "Several untranslated" {
+		t.Errorf("Expected 'Several untranslated' but got '%s'", tr)
+	}
+}
+
+func TestMoAndPoTranslator(t *testing.T) {
+
+	fixPath, _ := filepath.Abs("./fixtures/")
+
+	Configure(fixPath, "en_GB", "default")
+
+	// Check default domain Translation
+	SetDomain("default")
+	tr := Get("My text")
+	if tr != "Translated text" {
+		t.Errorf("Expected 'Translated text'. Got '%s'", tr)
+	}
+	tr = Get("language")
+	if tr != "en_GB" {
+		t.Errorf("Expected 'en_GB'. Got '%s'", tr)
+	}
+
+	// Change Language (locale)
+	SetLanguage("en_AU")
+
+	// Check default domain Translation
+	SetDomain("default")
+	tr = Get("My text")
+	if tr != "Translated text" {
+		t.Errorf("Expected 'Translated text'. Got '%s'", tr)
+	}
+	tr = Get("language")
+	if tr != "en_AU" {
+		t.Errorf("Expected 'en_AU'. Got '%s'", tr)
+	}
+}
+
+func TestDomains(t *testing.T) {
+	// Set PO content
+	strDefault := `
+msgid ""
+msgstr "Plural-Forms: nplurals=2; plural=(n != 1);\n"
+
+msgid "Default text"
+msgid_plural "Default texts"
+msgstr[0] "Default Translation"
+msgstr[1] "Default translations"
+
+msgctxt "Ctx"
+msgid "Default context"
+msgid_plural "Default contexts"
+msgstr[0] "Default ctx Translation"
+msgstr[1] "Default ctx translations"
+	`
+
+	strCustom := `
+msgid ""
+msgstr "Plural-Forms: nplurals=2; plural=(n != 1);\n"
+
+msgid "Custom text"
+msgid_plural "Custom texts"
+msgstr[0] "Custom Translation"
+msgstr[1] "Custom translations"
+
+msgctxt "Ctx"
+msgid "Custom context"
+msgid_plural "Custom contexts"
+msgstr[0] "Custom ctx Translation"
+msgstr[1] "Custom ctx translations"
+	`
+
+	// Create Locales directory and files on temp location
+	dirname := filepath.Join("/tmp", "en_US")
+	err := os.MkdirAll(dirname, os.ModePerm)
+	if err != nil {
+		t.Fatalf("Can't create test directory: %s", err.Error())
+	}
+
+	fDefault, err := os.Create(filepath.Join(dirname, "default.po"))
+	if err != nil {
+		t.Fatalf("Can't create test file: %s", err.Error())
+	}
+	defer fDefault.Close()
+
+	fCustom, err := os.Create(filepath.Join(dirname, "custom.po"))
+	if err != nil {
+		t.Fatalf("Can't create test file: %s", err.Error())
+	}
+	defer fCustom.Close()
+
+	_, err = fDefault.WriteString(strDefault)
+	if err != nil {
+		t.Fatalf("Can't write to test file: %s", err.Error())
+	}
+	_, err = fCustom.WriteString(strCustom)
+	if err != nil {
+		t.Fatalf("Can't write to test file: %s", err.Error())
+	}
+
+	Configure("/tmp", "en_US", "default")
+
+	// Check default domain Translation
+	SetDomain("default")
+	tr := Get("Default text")
+	if tr != "Default Translation" {
+		t.Errorf("Expected 'Default Translation'. Got '%s'", tr)
+	}
+	tr = GetN("Default text", "Default texts", 23)
+	if tr != "Default translations" {
+		t.Errorf("Expected 'Default translations'. Got '%s'", tr)
+	}
+	tr = GetC("Default context", "Ctx")
+	if tr != "Default ctx Translation" {
+		t.Errorf("Expected 'Default ctx Translation'. Got '%s'", tr)
+	}
+	tr = GetNC("Default context", "Default contexts", 23, "Ctx")
+	if tr != "Default ctx translations" {
+		t.Errorf("Expected 'Default ctx translations'. Got '%s'", tr)
+	}
+
+	SetDomain("custom")
+	tr = Get("Custom text")
+	if tr != "Custom Translation" {
+		t.Errorf("Expected 'Custom Translation'. Got '%s'", tr)
+	}
+	tr = GetN("Custom text", "Custom texts", 23)
+	if tr != "Custom translations" {
+		t.Errorf("Expected 'Custom translations'. Got '%s'", tr)
+	}
+	tr = GetC("Custom context", "Ctx")
+	if tr != "Custom ctx Translation" {
+		t.Errorf("Expected 'Custom ctx Translation'. Got '%s'", tr)
+	}
+	tr = GetNC("Custom context", "Custom contexts", 23, "Ctx")
+	if tr != "Custom ctx translations" {
+		t.Errorf("Expected 'Custom ctx translations'. Got '%s'", tr)
+	}
 }
 
 func TestPackageRace(t *testing.T) {
@@ -157,17 +400,21 @@ msgstr[0] "This one is the singular: %s"
 msgstr[1] "This one is the plural: %s"
 msgstr[2] "And this is the second plural form: %s"
 
-    `
+msgctxt "Ctx"
+msgid "Some random in a context"
+msgstr "Some random Translation in a context"
+
+	`
 
 	// Create Locales directory on default location
-	dirname := path.Clean(library + string(os.PathSeparator) + "en_US")
+	dirname := filepath.Join("/tmp", "en_US")
 	err := os.MkdirAll(dirname, os.ModePerm)
 	if err != nil {
 		t.Fatalf("Can't create test directory: %s", err.Error())
 	}
 
 	// Write PO content to default domain file
-	filename := path.Clean(dirname + string(os.PathSeparator) + domain + ".po")
+	filename := filepath.Join("/tmp", GetDomain()+".po")
 
 	f, err := os.Create(filename)
 	if err != nil {
@@ -180,20 +427,84 @@ msgstr[2] "And this is the second plural form: %s"
 		t.Fatalf("Can't write to test file: %s", err.Error())
 	}
 
-	// Init sync channels
-	c1 := make(chan bool)
-	c2 := make(chan bool)
+	var wg sync.WaitGroup
 
-	// Test translations
-	go func(done chan bool) {
-		Get("My text")
-		done <- true
-	}(c1)
+	for i := 0; i < 1000; i++ {
+		wg.Add(1)
+		// Test translations
+		go func() {
+			defer wg.Done()
 
-	go func(done chan bool) {
-		Get("My text")
-		done <- true
-	}(c2)
+			GetLibrary()
+			SetLibrary(filepath.Join("/tmp", "gotextlib"))
+			GetDomain()
+			SetDomain("default")
+			GetLanguage()
+			SetLanguage("en_US")
+			Configure("/tmp", "en_US", "default")
 
-	Get("My text")
+			Get("My text")
+			GetN("One with var: %s", "Several with vars: %s", 0, "test")
+			GetC("Some random in a context", "Ctx")
+		}()
+	}
+
+	wg.Wait()
+}
+
+func TestPackageArabicTranslation(t *testing.T) {
+	Configure("fixtures/", "ar", "categories")
+
+	// Plurals formula missing + Plural translation string missing
+	tr := GetD("categories", "Alcohol & Tobacco")
+	if tr != "الكحول والتبغ" {
+		t.Errorf("Expected to get 'الكحول والتبغ', but got '%s'", tr)
+	}
+
+	// Plural translation string present without translations, should get the msgid_plural
+	tr = GetND("categories", "%d selected", "%d selected", 10)
+	if tr != "%d selected" {
+		t.Errorf("Expected to get '%%d selected', but got '%s'", tr)
+	}
+
+	//Plurals formula present + Plural translation string present and complete
+	tr = GetND("categories", "Load %d more document", "Load %d more documents", 0)
+	if tr != "حمّل %d مستندات إضافيّة" {
+		t.Errorf("Expected to get 'msgstr[0]', but got '%s'", tr)
+	}
+
+	tr = GetND("categories", "Load %d more document", "Load %d more documents", 1)
+	if tr != "حمّل مستند واحد إضافي" {
+		t.Errorf("Expected to get 'msgstr[1]', but got '%s'", tr)
+	}
+
+	tr = GetND("categories", "Load %d more document", "Load %d more documents", 2)
+	if tr != "حمّل مستندين إضافيين" {
+		t.Errorf("Expected to get 'msgstr[2]', but got '%s'", tr)
+	}
+
+	tr = GetND("categories", "Load %d more document", "Load %d more documents", 6)
+	if tr != "حمّل %d مستندات إضافيّة" {
+		t.Errorf("Expected to get 'msgstr[3]', but got '%s'", tr)
+	}
+
+	tr = GetND("categories", "Load %d more document", "Load %d more documents", 116)
+	if tr != "حمّل %d مستندا إضافيّا" {
+		t.Errorf("Expected to get 'msgstr[4]', but got '%s'", tr)
+	}
+
+	tr = GetND("categories", "Load %d more document", "Load %d more documents", 102)
+	if tr != "حمّل %d مستند إضافي" {
+		t.Errorf("Expected to get 'msgstr[5]', but got '%s'", tr)
+	}
+}
+
+func TestPackageArabicMissingPluralForm(t *testing.T) {
+	Configure("fixtures/", "ar", "no_plural_header")
+
+	// Get translation
+	tr := GetD("no_plural_header", "Alcohol & Tobacco")
+	if tr != "الكحول والتبغ" {
+		t.Errorf("Expected to get 'الكحول والتبغ', but got '%s'", tr)
+	}
 }

helper.go

@@ -0,0 +1,86 @@
+/*
+ * Copyright (c) 2018 DeineAgentur UG https://www.deineagentur.com. All rights reserved.
+ * Licensed under the MIT License. See LICENSE file in the project root for full license information.
+ */
+
+package gotext
+
+import (
+	"fmt"
+	"regexp"
+	"strings"
+)
+
+var re = regexp.MustCompile(`%\(([a-zA-Z0-9_]+)\)[.0-9]*[svTtbcdoqXxUeEfFgGp]`)
+
+// SimplifiedLocale simplified locale like " en_US"/"de_DE "/en_US.UTF-8/zh_CN/zh_TW/el_GR@euro/... to en_US, de_DE, zh_CN, el_GR...
+func SimplifiedLocale(lang string) string {
+	// en_US/en_US.UTF-8/zh_CN/zh_TW/el_GR@euro/...
+	if idx := strings.Index(lang, ":"); idx != -1 {
+		lang = lang[:idx]
+	}
+	if idx := strings.Index(lang, "@"); idx != -1 {
+		lang = lang[:idx]
+	}
+	if idx := strings.Index(lang, "."); idx != -1 {
+		lang = lang[:idx]
+	}
+	return strings.TrimSpace(lang)
+}
+
+// Printf applies text formatting only when needed to parse variables.
+func Printf(str string, vars ...interface{}) string {
+	if len(vars) > 0 {
+		return fmt.Sprintf(str, vars...)
+	}
+
+	return str
+}
+
+// NPrintf support named format
+// NPrintf("%(name)s is Type %(type)s", map[string]interface{}{"name": "Gotext", "type": "struct"})
+func NPrintf(format string, params map[string]interface{}) {
+	f, p := parseSprintf(format, params)
+	fmt.Printf(f, p...)
+}
+
+// Sprintf support named format
+//      Sprintf("%(name)s is Type %(type)s", map[string]interface{}{"name": "Gotext", "type": "struct"})
+func Sprintf(format string, params map[string]interface{}) string {
+	f, p := parseSprintf(format, params)
+	return fmt.Sprintf(f, p...)
+}
+
+func parseSprintf(format string, params map[string]interface{}) (string, []interface{}) {
+	f, n := reformatSprintf(format)
+	var p []interface{}
+	for _, v := range n {
+		p = append(p, params[v])
+	}
+	return f, p
+}
+
+func reformatSprintf(f string) (string, []string) {
+	m := re.FindAllStringSubmatch(f, -1)
+	i := re.FindAllStringSubmatchIndex(f, -1)
+
+	ord := []string{}
+	for _, v := range m {
+		ord = append(ord, v[1])
+	}
+
+	pair := []int{0}
+	for _, v := range i {
+		pair = append(pair, v[2]-1)
+		pair = append(pair, v[3]+1)
+	}
+	pair = append(pair, len(f))
+	plen := len(pair)
+
+	out := ""
+	for n := 0; n < plen; n += 2 {
+		out += f[pair[n]:pair[n+1]]
+	}
+
+	return out, ord
+}

helper_test.go

@@ -0,0 +1,112 @@
+/*
+ * Copyright (c) 2018 DeineAgentur UG https://www.deineagentur.com. All rights reserved.
+ * Licensed under the MIT License. See LICENSE file in the project root for full license information.
+ */
+
+package gotext
+
+import (
+	"reflect"
+	"testing"
+)
+
+func TestSimplifiedLocale(t *testing.T) {
+	tr :=SimplifiedLocale("de_DE@euro")
+	if tr != "de_DE" {
+		t.Errorf("Expected 'de_DE' but got '%s'", tr)
+	}
+
+	tr =SimplifiedLocale("de_DE.UTF-8")
+	if tr != "de_DE" {
+		t.Errorf("Expected 'de_DE' but got '%s'", tr)
+	}
+
+	tr =SimplifiedLocale("de_DE:latin1")
+	if tr != "de_DE" {
+		t.Errorf("Expected 'de_DE' but got '%s'", tr)
+	}
+}
+
+func TestReformattingSingleNamedPattern(t *testing.T) {
+	pat := "%(name_me)x"
+
+	f, n := reformatSprintf(pat)
+
+	if f != "%x" {
+		t.Errorf("pattern should be %%x but %v", f)
+	}
+
+	if !reflect.DeepEqual(n, []string{"name_me"}) {
+		t.Errorf("named var should be {name_me} but %v", n)
+	}
+}
+
+func TestReformattingMultipleNamedPattern(t *testing.T) {
+	pat := "%(name_me)x and %(another_name)v"
+
+	f, n := reformatSprintf(pat)
+
+	if f != "%x and %v" {
+		t.Errorf("pattern should be %%x and %%v but %v", f)
+	}
+
+	if !reflect.DeepEqual(n, []string{"name_me", "another_name"}) {
+		t.Errorf("named var should be {name_me, another_name} but %v", n)
+	}
+}
+
+func TestReformattingRepeatedNamedPattern(t *testing.T) {
+	pat := "%(name_me)x and %(another_name)v and %(name_me)v"
+
+	f, n := reformatSprintf(pat)
+
+	if f != "%x and %v and %v" {
+		t.Errorf("pattern should be %%x and %%v and %%v but %v", f)
+	}
+
+	if !reflect.DeepEqual(n, []string{"name_me", "another_name", "name_me"}) {
+		t.Errorf("named var should be {name_me, another_name, name_me} but %v", n)
+	}
+}
+
+func TestSprintf(t *testing.T) {
+	pat := "%(brother)s loves %(sister)s. %(sister)s also loves %(brother)s."
+	params := map[string]interface{}{
+		"sister":  "Susan",
+		"brother": "Louis",
+	}
+
+	s := Sprintf(pat, params)
+
+	if s != "Louis loves Susan. Susan also loves Louis." {
+		t.Errorf("result should be Louis loves Susan. Susan also love Louis. but %v", s)
+	}
+}
+
+func TestNPrintf(t *testing.T) {
+	pat := "%(brother)s loves %(sister)s. %(sister)s also loves %(brother)s.\n"
+	params := map[string]interface{}{
+		"sister":  "Susan",
+		"brother": "Louis",
+	}
+
+	NPrintf(pat, params)
+
+}
+
+func TestSprintfFloatsWithPrecision(t *testing.T) {
+	pat := "%(float)f / %(floatprecision).1f / %(long)g / %(longprecision).3g"
+	params := map[string]interface{}{
+		"float": 5.034560,
+		"floatprecision": 5.03456,
+		"long": 5.03456,
+		"longprecision": 5.03456,
+	}
+
+	s := Sprintf(pat, params)
+
+	expectedresult := "5.034560 / 5.0 / 5.03456 / 5.03"
+	if s != expectedresult {
+		t.Errorf("result should be (%v) but is (%v)", expectedresult, s)
+	}
+}

locale.go

@@ -1,9 +1,15 @@
+/*
+ * Copyright (c) 2018 DeineAgentur UG https://www.deineagentur.com. All rights reserved.
+ * Licensed under the MIT License. See LICENSE file in the project root for full license information.
+ */
+
 package gotext
 
 import (
-	"fmt"
+	"bytes"
+	"encoding/gob"
 	"os"
-	"path"
+	"path/filepath"
 	"sync"
 )
 
@@ -14,25 +20,29 @@ multiple languages at the same time by working with this object.
 
 Example:
 
-    import "github.com/leonelquinteros/gotext"
+    import (
+		"encoding/gob"
+		"bytes"
+		"fmt"
+		"git.deineagentur.com/DeineAgenturUG/gotext"
+    )
 
     func main() {
         // Create Locale with library path and language code
         l := gotext.NewLocale("/path/to/i18n/dir", "en_US")
 
-        // Load domain '/path/to/i18n/dir/en_US/LC_MESSAGES/default.po'
+        // Load domain '/path/to/i18n/dir/en_US/LC_MESSAGES/default.{po,mo}'
         l.AddDomain("default")
 
         // Translate text from default domain
-        println(l.Get("Translate this"))
+        fmt.Println(l.Get("Translate this"))
 
-        // Load different domain ('/path/to/i18n/dir/en_US/LC_MESSAGES/extras.po')
+        // Load different domain ('/path/to/i18n/dir/en_US/LC_MESSAGES/extras.{po,mo}')
         l.AddDomain("extras")
 
         // Translate text from domain
-        println(l.GetD("extras", "Translate this"))
-    }
-
+		fmt.Println(l.GetD("extras", "Translate this"))
+	}
 */
 type Locale struct {
 	// Path to locale files.
@@ -41,136 +51,403 @@ type Locale struct {
 	// Language for this Locale
 	lang string
 
-	// List of available domains for this locale.
-	domains map[string]*Po
+	// List of available Domains for this locale.
+	Domains map[string]Translator
+
+	// First AddDomain is default Domain
+	defaultDomain string
 
 	// Sync Mutex
 	sync.RWMutex
 }
 
 // NewLocale creates and initializes a new Locale object for a given language.
-// It receives a path for the i18n files directory (p) and a language code to use (l).
+// It receives a path for the i18n .po/.mo files directory (p) and a language code to use (l).
 func NewLocale(p, l string) *Locale {
 	return &Locale{
 		path:    p,
-		lang:    l,
-		domains: make(map[string]*Po),
+		lang:    SimplifiedLocale(l),
+		Domains: make(map[string]Translator),
 	}
 }
 
-func (l *Locale) findPO(dom string) string {
-	filename := path.Join(l.path, l.lang, "LC_MESSAGES", dom+".po")
+//SetLang ...
+func (l *Locale) SetLang(lang string) {
+	l.lang = lang
+}
+
+//GetLang ...
+func (l *Locale) GetLang() string {
+	return l.lang
+}
+
+//SetPath ...
+func (l *Locale) SetPath(path string) {
+	l.path = path
+}
+
+func (l *Locale) findExt(dom, ext string) string {
+	filename := filepath.Join(l.path, l.lang, "LC_MESSAGES", dom+"."+ext)
 	if _, err := os.Stat(filename); err == nil {
 		return filename
 	}
 
 	if len(l.lang) > 2 {
-		filename = path.Join(l.path, l.lang[:2], "LC_MESSAGES", dom+".po")
+		filename = filepath.Join(l.path, l.lang[:2], "LC_MESSAGES", dom+"."+ext)
 		if _, err := os.Stat(filename); err == nil {
 			return filename
 		}
 	}
 
-	filename = path.Join(l.path, l.lang, dom+".po")
+	filename = filepath.Join(l.path, l.lang, dom+"."+ext)
 	if _, err := os.Stat(filename); err == nil {
 		return filename
 	}
 
 	if len(l.lang) > 2 {
-		filename = path.Join(l.path, l.lang[:2], dom+".po")
+		filename = filepath.Join(l.path, l.lang[:2], dom+"."+ext)
+		if _, err := os.Stat(filename); err == nil {
+			return filename
+		}
 	}
 
-	return filename
+	return ""
 }
 
 // AddDomain creates a new domain for a given locale object and initializes the Po object.
 // If the domain exists, it gets reloaded.
 func (l *Locale) AddDomain(dom string) {
-	po := new(Po)
+	var poObj Translator
 
-	// Parse file.
-	po.ParseFile(l.findPO(dom))
+	file := l.findExt(dom, "po")
+	if file != "" {
+		poObj = new(Po)
+		// Parse file.
+		poObj.ParseFile(file)
+	} else {
+		file = l.findExt(dom, "mo")
+		if file != "" {
+			poObj = new(Mo)
+			// Parse file.
+			poObj.ParseFile(file)
+		} else {
+			// fallback return if no file found with
+			return
+		}
+	}
 
 	// Save new domain
 	l.Lock()
-	defer l.Unlock()
 
-	if l.domains == nil {
-		l.domains = make(map[string]*Po)
+	if l.Domains == nil {
+		l.Domains = make(map[string]Translator)
 	}
-	l.domains[dom] = po
+	if l.defaultDomain == "" {
+		l.defaultDomain = dom
+	}
+	l.Domains[dom] = poObj
+
+	// Unlock "Save new domain"
+	l.Unlock()
 }
 
-// Get uses a domain "default" to return the corresponding translation of a given string.
+// AddTranslator takes a domain name and a Translator object to make it available in the Locale object.
+func (l *Locale) AddTranslator(dom string, tr Translator) {
+	l.Lock()
+
+	if l.Domains == nil {
+		l.Domains = make(map[string]Translator)
+	}
+	if l.defaultDomain == "" {
+		l.defaultDomain = dom
+	}
+	l.Domains[dom] = tr
+
+	l.Unlock()
+}
+
+// GetDomain is the domain getter for Locale configuration
+func (l *Locale) GetDomain() string {
+	l.RLock()
+	dom := l.defaultDomain
+	l.RUnlock()
+	return dom
+}
+
+// SetDomain sets the name for the domain to be used.
+func (l *Locale) SetDomain(dom string) {
+	l.Lock()
+	l.defaultDomain = dom
+	l.Unlock()
+}
+
+// Get uses a domain "default" to return the corresponding Translation of a given string.
 // Supports optional parameters (vars... interface{}) to be inserted on the formatted string using the fmt.Printf syntax.
 func (l *Locale) Get(str string, vars ...interface{}) string {
-	return l.GetD("default", str, vars...)
+	return l.GetD(l.GetDomain(), str, vars...)
 }
 
-// GetN retrieves the (N)th plural form of translation for the given string in the "default" domain.
+// GetN retrieves the (N)th plural form of Translation for the given string in the "default" domain.
 // Supports optional parameters (vars... interface{}) to be inserted on the formatted string using the fmt.Printf syntax.
 func (l *Locale) GetN(str, plural string, n int, vars ...interface{}) string {
-	return l.GetND("default", str, plural, n, vars...)
+	return l.GetND(l.GetDomain(), str, plural, n, vars...)
 }
 
-// GetD returns the corresponding translation in the given domain for the given string.
+// GetD returns the corresponding Translation in the given domain for the given string.
 // Supports optional parameters (vars... interface{}) to be inserted on the formatted string using the fmt.Printf syntax.
 func (l *Locale) GetD(dom, str string, vars ...interface{}) string {
-	return l.GetND(dom, str, str, 1, vars...)
+	// Sync read
+	l.RLock()
+	defer l.RUnlock()
+
+	if l.Domains != nil {
+		if _, ok := l.Domains[dom]; ok {
+			if l.Domains[dom] != nil {
+				return l.Domains[dom].Get(str, vars...)
+			}
+		}
+	}
+
+	return Printf(str, vars...)
 }
 
-// GetND retrieves the (N)th plural form of translation in the given domain for the given string.
+// GetND retrieves the (N)th plural form of Translation in the given domain for the given string.
 // Supports optional parameters (vars... interface{}) to be inserted on the formatted string using the fmt.Printf syntax.
 func (l *Locale) GetND(dom, str, plural string, n int, vars ...interface{}) string {
 	// Sync read
 	l.RLock()
 	defer l.RUnlock()
 
-	if l.domains != nil {
-		if _, ok := l.domains[dom]; ok {
-			if l.domains[dom] != nil {
-				return l.domains[dom].GetN(str, plural, n, vars...)
+	if l.Domains != nil {
+		if _, ok := l.Domains[dom]; ok {
+			if l.Domains[dom] != nil {
+				return l.Domains[dom].GetN(str, plural, n, vars...)
 			}
 		}
 	}
 
-	// Return the same we received by default
-	return fmt.Sprintf(plural, vars...)
+	// Use western default rule (plural > 1) to handle missing domain default result.
+	if n == 1 {
+		return Printf(str, vars...)
+	}
+	return Printf(plural, vars...)
 }
 
-// GetC uses a domain "default" to return the corresponding translation of the given string in the given context.
+// GetC uses a domain "default" to return the corresponding Translation of the given string in the given context.
 // Supports optional parameters (vars... interface{}) to be inserted on the formatted string using the fmt.Printf syntax.
 func (l *Locale) GetC(str, ctx string, vars ...interface{}) string {
-	return l.GetDC("default", str, ctx, vars...)
+	return l.GetDC(l.GetDomain(), str, ctx, vars...)
 }
 
-// GetNC retrieves the (N)th plural form of translation for the given string in the given context in the "default" domain.
+// GetNC retrieves the (N)th plural form of Translation for the given string in the given context in the "default" domain.
 // Supports optional parameters (vars... interface{}) to be inserted on the formatted string using the fmt.Printf syntax.
 func (l *Locale) GetNC(str, plural string, n int, ctx string, vars ...interface{}) string {
-	return l.GetNDC("default", str, plural, n, ctx, vars...)
+	return l.GetNDC(l.GetDomain(), str, plural, n, ctx, vars...)
 }
 
-// GetDC returns the corresponding translation in the given domain for the given string in the given context.
+// GetDC returns the corresponding Translation in the given domain for the given string in the given context.
 // Supports optional parameters (vars... interface{}) to be inserted on the formatted string using the fmt.Printf syntax.
 func (l *Locale) GetDC(dom, str, ctx string, vars ...interface{}) string {
-	return l.GetNDC(dom, str, str, 1, ctx, vars...)
+	// Sync read
+	l.RLock()
+	defer l.RUnlock()
+
+	if l.Domains != nil {
+		if _, ok := l.Domains[dom]; ok {
+			if l.Domains[dom] != nil {
+				return l.Domains[dom].GetC(str, ctx, vars...)
+			}
+		}
+	}
+
+	return Printf(str, vars...)
 }
 
-// GetNDC retrieves the (N)th plural form of translation in the given domain for the given string in the given context.
+// GetNDC retrieves the (N)th plural form of Translation in the given domain for the given string in the given context.
 // Supports optional parameters (vars... interface{}) to be inserted on the formatted string using the fmt.Printf syntax.
 func (l *Locale) GetNDC(dom, str, plural string, n int, ctx string, vars ...interface{}) string {
 	// Sync read
 	l.RLock()
 	defer l.RUnlock()
 
-	if l.domains != nil {
-		if _, ok := l.domains[dom]; ok {
-			if l.domains[dom] != nil {
-				return l.domains[dom].GetNC(str, plural, n, ctx, vars...)
+	if l.Domains != nil {
+		if _, ok := l.Domains[dom]; ok {
+			if l.Domains[dom] != nil {
+				return l.Domains[dom].GetNC(str, plural, n, ctx, vars...)
 			}
 		}
 	}
 
-	// Return the same we received by default
-	return fmt.Sprintf(plural, vars...)
+	// Use western default rule (plural > 1) to handle missing domain default result.
+	if n == 1 {
+		return Printf(str, vars...)
+	}
+	return Printf(plural, vars...)
+}
+
+// GetE uses a domain "default" to return the corresponding Translation of a given string.
+// Supports optional parameters (vars... interface{}) to be inserted on the formatted string using the fmt.Printf syntax.
+// The second return value is true iff the string was found.
+func (l *Locale) GetE(str string, vars ...interface{}) (string, bool) {
+	return l.GetDE(l.GetDomain(), str, vars...)
+}
+
+// GetNE retrieves the (N)th plural form of Translation for the given string in the "default" domain.
+// Supports optional parameters (vars... interface{}) to be inserted on the formatted string using the fmt.Printf syntax.
+// The second return value is true iff the string was found.
+func (l *Locale) GetNE(str, plural string, n int, vars ...interface{}) (string, bool) {
+	return l.GetNDE(l.GetDomain(), str, plural, n, vars...)
+}
+
+// GetDE returns the corresponding Translation in the given domain for the given string.
+// Supports optional parameters (vars... interface{}) to be inserted on the formatted string using the fmt.Printf syntax.
+// The second return value is true iff the string was found.
+func (l *Locale) GetDE(dom, str string, vars ...interface{}) (string, bool) {
+	// Sync read
+	l.RLock()
+	defer l.RUnlock()
+
+	if l.Domains != nil {
+		if _, ok := l.Domains[dom]; ok {
+			if l.Domains[dom] != nil {
+				return l.Domains[dom].GetE(str, vars...)
+			}
+		}
+	}
+
+	return "", false
+}
+
+// GetNDE retrieves the (N)th plural form of Translation in the given domain for the given string.
+// Supports optional parameters (vars... interface{}) to be inserted on the formatted string using the fmt.Printf syntax.
+// The second return value is true iff the string was found.
+func (l *Locale) GetNDE(dom, str, plural string, n int, vars ...interface{}) (string, bool) {
+	// Sync read
+	l.RLock()
+	defer l.RUnlock()
+
+	if l.Domains != nil {
+		if _, ok := l.Domains[dom]; ok {
+			if l.Domains[dom] != nil {
+				return l.Domains[dom].GetNE(str, plural, n, vars...)
+			}
+		}
+	}
+
+	// Use western default rule (plural > 1) to handle missing domain default result.
+	return "", false
+}
+
+// GetCE uses a domain "default" to return the corresponding Translation of the given string in the given context.
+// Supports optional parameters (vars... interface{}) to be inserted on the formatted string using the fmt.Printf syntax.
+// The second return value is true iff the string was found.
+func (l *Locale) GetCE(str, ctx string, vars ...interface{}) (string, bool) {
+	return l.GetDCE(l.GetDomain(), str, ctx, vars...)
+}
+
+// GetNCE retrieves the (N)th plural form of Translation for the given string in the given context in the "default" domain.
+// Supports optional parameters (vars... interface{}) to be inserted on the formatted string using the fmt.Printf syntax.
+// The second return value is true iff the string was found.
+func (l *Locale) GetNCE(str, plural string, n int, ctx string, vars ...interface{}) (string, bool) {
+	return l.GetNDCE(l.GetDomain(), str, plural, n, ctx, vars...)
+}
+
+// GetDCE returns the corresponding Translation in the given domain for the given string in the given context.
+// Supports optional parameters (vars... interface{}) to be inserted on the formatted string using the fmt.Printf syntax.
+func (l *Locale) GetDCE(dom, str, ctx string, vars ...interface{}) (string, bool) {
+	// Sync read
+	l.RLock()
+	defer l.RUnlock()
+
+	if l.Domains != nil {
+		if _, ok := l.Domains[dom]; ok {
+			if l.Domains[dom] != nil {
+				return l.Domains[dom].GetCE(str, ctx, vars...)
+			}
+		}
+	}
+
+	return "", false
+}
+
+// GetNDCE retrieves the (N)th plural form of Translation in the given domain for the given string in the given context.
+// Supports optional parameters (vars... interface{}) to be inserted on the formatted string using the fmt.Printf syntax.
+// The second return value is true iff the string was found.
+func (l *Locale) GetNDCE(dom, str, plural string, n int, ctx string, vars ...interface{}) (string, bool) {
+	// Sync read
+	l.RLock()
+	defer l.RUnlock()
+
+	if l.Domains != nil {
+		if _, ok := l.Domains[dom]; ok {
+			if l.Domains[dom] != nil {
+				return l.Domains[dom].GetNCE(str, plural, n, ctx, vars...)
+			}
+		}
+	}
+
+	// Use western default rule (plural > 1) to handle missing domain default result.
+	return "", false
+}
+
+// LocaleEncoding is used as intermediary storage to encode Locale objects to Gob.
+type LocaleEncoding struct {
+	Path          string
+	Lang          string
+	Domains       map[string][]byte
+	DefaultDomain string
+}
+
+// MarshalBinary implements encoding BinaryMarshaler interface
+func (l *Locale) MarshalBinary() ([]byte, error) {
+	obj := new(LocaleEncoding)
+	obj.DefaultDomain = l.defaultDomain
+	obj.Domains = make(map[string][]byte)
+	for k, v := range l.Domains {
+		var err error
+		obj.Domains[k], err = v.MarshalBinary()
+		if err != nil {
+			return nil, err
+		}
+	}
+	obj.Lang = l.lang
+	obj.Path = l.path
+
+	var buff bytes.Buffer
+	encoder := gob.NewEncoder(&buff)
+	err := encoder.Encode(obj)
+
+	return buff.Bytes(), err
+}
+
+// UnmarshalBinary implements encoding BinaryUnmarshaler interface
+func (l *Locale) UnmarshalBinary(data []byte) error {
+	buff := bytes.NewBuffer(data)
+	obj := new(LocaleEncoding)
+
+	decoder := gob.NewDecoder(buff)
+	err := decoder.Decode(obj)
+	if err != nil {
+		return err
+	}
+
+	l.defaultDomain = obj.DefaultDomain
+	l.lang = obj.Lang
+	l.path = obj.Path
+
+	// Decode Domains
+	l.Domains = make(map[string]Translator)
+	for k, v := range obj.Domains {
+		var tr TranslatorEncoding
+		buff := bytes.NewBuffer(v)
+		trDecoder := gob.NewDecoder(buff)
+		err := trDecoder.Decode(&tr)
+		if err != nil {
+			return err
+		}
+
+		l.Domains[k] = tr.GetTranslator()
+	}
+
+	return nil
 }

locale_test.go

@@ -1,8 +1,13 @@
+/*
+ * Copyright (c) 2018 DeineAgentur UG https://www.deineagentur.com. All rights reserved.
+ * Licensed under the MIT License. See LICENSE file in the project root for full license information.
+ */
+
 package gotext
 
 import (
 	"os"
-	"path"
+	"path/filepath"
 	"testing"
 )
 
@@ -38,8 +43,6 @@ msgstr[abc] "Wrong index"
 msgstr[1 "Forgot to close brackets"
 msgstr[0] "Badly formatted string'
 
-msgid "Invalid formatted id[] with no translations
-
 msgctxt "Ctx"
 msgid "One with var: %s"
 msgid_plural "Several with vars: %s"
@@ -47,26 +50,26 @@ msgstr[0] "This one is the singular in a Ctx context: %s"
 msgstr[1] "This one is the plural in a Ctx context: %s"
 
 msgid "Some random"
-msgstr "Some random translation"
+msgstr "Some random Translation"
 
 msgctxt "Ctx"
 msgid "Some random in a context"
-msgstr "Some random translation in a context"
+msgstr "Some random Translation in a context"
 
 msgid "More"
-msgstr "More translation"
+msgstr "More Translation"
 
-    `
+	`
 
 	// Create Locales directory with simplified language code
-	dirname := path.Join("/tmp", "en", "LC_MESSAGES")
+	dirname := filepath.Join("/tmp", "en", "LC_MESSAGES")
 	err := os.MkdirAll(dirname, os.ModePerm)
 	if err != nil {
 		t.Fatalf("Can't create test directory: %s", err.Error())
 	}
 
 	// Write PO content to file
-	filename := path.Join(dirname, "my_domain.po")
+	filename := filepath.Join(dirname, "my_domain.po")
 
 	f, err := os.Create(filename)
 	if err != nil {
@@ -83,7 +86,7 @@ msgstr "More translation"
 	l := NewLocale("/tmp", "en_US")
 
 	// Force nil domain storage
-	l.domains = nil
+	l.Domains = nil
 
 	// Add domain
 	l.AddDomain("my_domain")
@@ -107,7 +110,17 @@ msgstr "More translation"
 	}
 
 	// Test context translations
+	tr = l.GetC("Some random in a context", "Ctx")
+	if tr != "Some random Translation in a context" {
+		t.Errorf("Expected 'Some random Translation in a context'. Got '%s'", tr)
+	}
+
 	v = "Test"
+	tr = l.GetNC("One with var: %s", "Several with vars: %s", 23, "Ctx", v)
+	if tr != "This one is the plural in a Ctx context: Test" {
+		t.Errorf("Expected 'This one is the plural in a Ctx context: Test'. Got '%s'", tr)
+	}
+
 	tr = l.GetDC("my_domain", "One with var: %s", "Ctx", v)
 	if tr != "This one is the singular in a Ctx context: Test" {
 		t.Errorf("Expected 'This one is the singular in a Ctx context: Test' but got '%s'", tr)
@@ -119,10 +132,10 @@ msgstr "More translation"
 		t.Errorf("Expected 'This one is the plural in a Ctx context: Test' but got '%s'", tr)
 	}
 
-	// Test last translation
+	// Test last Translation
 	tr = l.GetD("my_domain", "More")
-	if tr != "More translation" {
-		t.Errorf("Expected 'More translation' but got '%s'", tr)
+	if tr != "More Translation" {
+		t.Errorf("Expected 'More Translation' but got '%s'", tr)
 	}
 }
 
@@ -167,26 +180,26 @@ msgstr[0] "This one is the singular in a Ctx context: %s"
 msgstr[1] "This one is the plural in a Ctx context: %s"
 
 msgid "Some random"
-msgstr "Some random translation"
+msgstr "Some random Translation"
 
 msgctxt "Ctx"
 msgid "Some random in a context"
-msgstr "Some random translation in a context"
+msgstr "Some random Translation in a context"
 
 msgid "More"
-msgstr "More translation"
+msgstr "More Translation"
 
-    `
+	`
 
 	// Create Locales directory with simplified language code
-	dirname := path.Join("/tmp", "en", "LC_MESSAGES")
+	dirname := filepath.Join("/tmp", "en", "LC_MESSAGES")
 	err := os.MkdirAll(dirname, os.ModePerm)
 	if err != nil {
 		t.Fatalf("Can't create test directory: %s", err.Error())
 	}
 
 	// Write PO content to file
-	filename := path.Join(dirname, "my_domain.po")
+	filename := filepath.Join(dirname, "my_domain.po")
 
 	f, err := os.Create(filename)
 	if err != nil {
@@ -203,13 +216,28 @@ msgstr "More translation"
 	l := NewLocale("/tmp", "en_US")
 
 	// Force nil domain storage
-	l.domains = nil
+	l.Domains = nil
 
 	// Add domain
 	l.AddDomain("my_domain")
 
-	// Test non-existent "deafult" domain responses
-	tr := l.Get("My text")
+	// Test non-existent "default" domain responses
+	tr := l.GetDomain()
+	if tr != "my_domain" {
+		t.Errorf("Expected 'my_domain' but got '%s'", tr)
+	}
+
+	// Set default domain to make it fail
+	l.SetDomain("default")
+
+	// Test non-existent "default" domain responses
+	tr = l.GetDomain()
+	if tr != "default" {
+		t.Errorf("Expected 'default' but got '%s'", tr)
+	}
+
+	// Test non-existent "default" domain responses
+	tr = l.Get("My text")
 	if tr != "My text" {
 		t.Errorf("Expected 'My text' but got '%s'", tr)
 	}
@@ -227,6 +255,11 @@ msgstr "More translation"
 	}
 
 	tr = l.GetN("This is a test", "This are tests", 1)
+	if tr != "This is a test" {
+		t.Errorf("Expected 'This is a test' but got '%s'", tr)
+	}
+
+	tr = l.GetN("This is a test", "This are tests", 7)
 	if tr != "This are tests" {
 		t.Errorf("Expected 'This are tests' but got '%s'", tr)
 	}
@@ -238,8 +271,138 @@ msgstr "More translation"
 	}
 
 	tr = l.GetN("This one has invalid syntax translations", "This are tests", 1)
+	if tr != "This one has invalid syntax translations" {
+		t.Errorf("Expected 'This one has invalid syntax translations' but got '%s'", tr)
+	}
+	tr = l.GetN("This one has invalid syntax translations", "This are tests", 2)
 	if tr != "This are tests" {
-		t.Errorf("Expected 'Plural index' but got '%s'", tr)
+		t.Errorf("Expected 'This are tests' but got '%s'", tr)
+	}
+
+	// Create Locale with full language code
+	l = NewLocale("/tmp", "golem")
+
+	// Force nil domain storage
+	l.Domains = nil
+
+	// Add domain
+	l.SetDomain("my_domain")
+
+	// Test non-existent "default" domain responses
+	tr = l.GetDomain()
+	if tr != "my_domain" {
+		t.Errorf("Expected 'my_domain' but got '%s'", tr)
+	}
+
+	// Test syntax error parsed translations
+	tr = l.Get("This one has invalid syntax translations")
+	if tr != "This one has invalid syntax translations" {
+		t.Errorf("Expected 'This one has invalid syntax translations' but got '%s'", tr)
+	}
+
+	tr = l.GetN("This one has invalid syntax translations", "This are tests", 1)
+	if tr != "This one has invalid syntax translations" {
+		t.Errorf("Expected 'This one has invalid syntax translations' but got '%s'", tr)
+	}
+	tr = l.GetN("This one has invalid syntax translations", "This are tests", 111)
+	if tr != "This are tests" {
+		t.Errorf("Expected 'This are tests' but got '%s'", tr)
+	}
+
+	// Create Locale with full language code
+	l = NewLocale("fixtures/", "fr_FR")
+
+	// Force nil domain storage
+	l.Domains = nil
+
+	// Add domain
+	l.SetDomain("default")
+
+	// Test non-existent "default" domain responses
+	tr = l.GetDomain()
+	if tr != "default" {
+		t.Errorf("Expected 'my_domain' but got '%s'", tr)
+	}
+
+	// Test syntax error parsed translations
+	tr = l.Get("This one has invalid syntax translations")
+	if tr != "This one has invalid syntax translations" {
+		t.Errorf("Expected 'This one has invalid syntax translations' but got '%s'", tr)
+	}
+
+	tr = l.GetN("This one has invalid syntax translations", "This are tests", 1)
+	if tr != "This one has invalid syntax translations" {
+		t.Errorf("Expected 'This one has invalid syntax translations' but got '%s'", tr)
+	}
+	tr = l.GetN("This one has invalid syntax translations", "This are tests", 21)
+	if tr != "This are tests" {
+		t.Errorf("Expected 'This are tests' but got '%s'", tr)
+	}
+
+	// Create Locale with full language code
+	l = NewLocale("fixtures/", "de_DE")
+
+	// Force nil domain storage
+	l.Domains = nil
+
+	// Add domain
+	l.SetDomain("default")
+
+	// Test non-existent "default" domain responses
+	tr = l.GetDomain()
+	if tr != "default" {
+		t.Errorf("Expected 'my_domain' but got '%s'", tr)
+	}
+
+	// Test syntax error parsed translations
+	tr = l.Get("This one has invalid syntax translations")
+	if tr != "This one has invalid syntax translations" {
+		t.Errorf("Expected 'This one has invalid syntax translations' but got '%s'", tr)
+	}
+
+	tr = l.GetN("This one has invalid syntax translations", "This are tests", 1)
+	if tr != "This one has invalid syntax translations" {
+		t.Errorf("Expected 'This one has invalid syntax translations' but got '%s'", tr)
+	}
+	tr = l.GetN("This one has invalid syntax translations", "This are tests", 2)
+	if tr != "This are tests" {
+		t.Errorf("Expected 'This are tests' but got '%s'", tr)
+	}
+
+	// Create Locale with full language code
+	l = NewLocale("fixtures/", "de_AT")
+
+	// Force nil domain storage
+	l.Domains = nil
+
+	// Add domain
+	l.SetDomain("default")
+
+	// Test non-existent "default" domain responses
+	tr = l.GetDomain()
+	if tr != "default" {
+		t.Errorf("Expected 'my_domain' but got '%s'", tr)
+	}
+
+	// Test syntax error parsed translations
+	tr = l.Get("This one has invalid syntax translations")
+	if tr != "This one has invalid syntax translations" {
+		t.Errorf("Expected 'This one has invalid syntax translations' but got '%s'", tr)
+	}
+
+	// Test syntax error parsed translations
+	tr = l.GetNDC("mega", "This one has invalid syntax translations", "plural", 2, "ctx")
+	if tr != "plural" {
+		t.Errorf("Expected 'plural' but got '%s'", tr)
+	}
+
+	tr = l.GetN("This one has invalid syntax translations", "This are tests", 1)
+	if tr != "This one has invalid syntax translations" {
+		t.Errorf("Expected 'This one has invalid syntax translations' but got '%s'", tr)
+	}
+	tr = l.GetN("This one has invalid syntax translations", "This are tests", 14)
+	if tr != "This are tests" {
+		t.Errorf("Expected 'This are tests' but got '%s'", tr)
 	}
 }
 
@@ -259,17 +422,17 @@ msgstr[0] "This one is the singular: %s"
 msgstr[1] "This one is the plural: %s"
 msgstr[2] "And this is the second plural form: %s"
 
-    `
+	`
 
 	// Create Locales directory with simplified language code
-	dirname := path.Join("/tmp", "es")
+	dirname := filepath.Join("/tmp", "es")
 	err := os.MkdirAll(dirname, os.ModePerm)
 	if err != nil {
 		t.Fatalf("Can't create test directory: %s", err.Error())
 	}
 
 	// Write PO content to file
-	filename := path.Join(dirname, "race.po")
+	filename := filepath.Join(dirname, "race.po")
 
 	f, err := os.Create(filename)
 	if err != nil {
@@ -282,7 +445,7 @@ msgstr[2] "And this is the second plural form: %s"
 		t.Fatalf("Can't write to test file: %s", err.Error())
 	}
 
-	// Create Locale with full language code
+	// Create Locale
 	l := NewLocale("/tmp", "es")
 
 	// Init sync channels
@@ -308,3 +471,133 @@ msgstr[2] "And this is the second plural form: %s"
 	<-ac
 	<-rc
 }
+
+func TestAddTranslator(t *testing.T) {
+	// Create po object
+	po := new(Po)
+
+	// Parse file
+	po.ParseFile("fixtures/en_US/default.po")
+
+	// Create Locale
+	l := NewLocale("", "en")
+
+	// Add PO Translator to Locale object
+	l.AddTranslator("default", po)
+
+	// Test translations
+	tr := l.Get("My text")
+	if tr != "Translated text" {
+		t.Errorf("Expected 'Translated text' but got '%s'", tr)
+	}
+	// Test translations
+	tr = l.Get("language")
+	if tr != "en_US" {
+		t.Errorf("Expected 'en_US' but got '%s'", tr)
+	}
+}
+
+func TestArabicTranslation(t *testing.T) {
+	// Create Locale
+	l := NewLocale("fixtures/", "ar")
+
+	// Add domain
+	l.AddDomain("categories")
+
+	// Plurals formula missing + Plural translation string missing
+	tr := l.GetD("categories", "Alcohol & Tobacco")
+	if tr != "الكحول والتبغ" {
+		t.Errorf("Expected to get 'الكحول والتبغ', but got '%s'", tr)
+	}
+
+	// Plural translation string present without translations, should get the msgid_plural
+	tr = l.GetND("categories", "%d selected", "%d selected", 10)
+	if tr != "%d selected" {
+		t.Errorf("Expected to get '%%d selected', but got '%s'", tr)
+	}
+
+	//Plurals formula present + Plural translation string present and complete
+	tr = l.GetND("categories", "Load %d more document", "Load %d more documents", 0)
+	if tr != "حمّل %d مستندات إضافيّة" {
+		t.Errorf("Expected to get 'msgstr[0]', but got '%s'", tr)
+	}
+
+	tr = l.GetND("categories", "Load %d more document", "Load %d more documents", 1)
+	if tr != "حمّل مستند واحد إضافي" {
+		t.Errorf("Expected to get 'msgstr[1]', but got '%s'", tr)
+	}
+
+	tr = l.GetND("categories", "Load %d more document", "Load %d more documents", 2)
+	if tr != "حمّل مستندين إضافيين" {
+		t.Errorf("Expected to get 'msgstr[2]', but got '%s'", tr)
+	}
+
+	tr = l.GetND("categories", "Load %d more document", "Load %d more documents", 6)
+	if tr != "حمّل %d مستندات إضافيّة" {
+		t.Errorf("Expected to get 'msgstr[3]', but got '%s'", tr)
+	}
+
+	tr = l.GetND("categories", "Load %d more document", "Load %d more documents", 116)
+	if tr != "حمّل %d مستندا إضافيّا" {
+		t.Errorf("Expected to get 'msgstr[4]', but got '%s'", tr)
+	}
+
+	tr = l.GetND("categories", "Load %d more document", "Load %d more documents", 102)
+	if tr != "حمّل %d مستند إضافي" {
+		t.Errorf("Expected to get 'msgstr[5]', but got '%s'", tr)
+	}
+
+}
+
+func TestArabicMissingPluralForm(t *testing.T) {
+	// Create Locale
+	l := NewLocale("fixtures/", "ar")
+
+	// Add domain
+	l.AddDomain("no_plural_header")
+
+	// Get translation
+	tr := l.GetD("no_plural_header", "Alcohol & Tobacco")
+	if tr != "الكحول والتبغ" {
+		t.Errorf("Expected to get 'الكحول والتبغ', but got '%s'", tr)
+	}
+}
+
+func TestLocaleBinaryEncoding(t *testing.T) {
+	// Create Locale
+	l := NewLocale("fixtures/", "en_US")
+	l.AddDomain("default")
+
+	buff, err := l.MarshalBinary()
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	l2 := new(Locale)
+	err = l2.UnmarshalBinary(buff)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	// Check object properties
+	if l.path != l2.path {
+		t.Fatalf("path doesn't match: '%s' vs '%s'", l.path, l2.path)
+	}
+	if l.lang != l2.lang {
+		t.Fatalf("lang doesn't match: '%s' vs '%s'", l.lang, l2.lang)
+	}
+	if l.defaultDomain != l2.defaultDomain {
+		t.Fatalf("defaultDomain doesn't match: '%s' vs '%s'", l.defaultDomain, l2.defaultDomain)
+	}
+
+	// Check translations
+	if l.Get("My text") != l2.Get("My text") {
+		t.Errorf("'%s' is different from '%s", l.Get("My text"), l2.Get("My text"))
+	}
+	if l.Get("More") != l2.Get("More") {
+		t.Errorf("'%s' is different from '%s", l.Get("More"), l2.Get("More"))
+	}
+	if l.GetN("One with var: %s", "Several with vars: %s", 3, "VALUE") != l2.GetN("One with var: %s", "Several with vars: %s", 3, "VALUE") {
+		t.Errorf("'%s' is different from '%s", l.GetN("One with var: %s", "Several with vars: %s", 3, "VALUE"), l2.GetN("One with var: %s", "Several with vars: %s", 3, "VALUE"))
+	}
+}

mo.go

@@ -0,0 +1,556 @@
+/*
+ * Copyright (c) 2018 DeineAgentur UG https://www.deineagentur.com. All rights reserved.
+ * Licensed under the MIT License. See LICENSE file in the project root for full license information.
+ */
+
+package gotext
+
+import (
+	"bufio"
+	"bytes"
+	"encoding/binary"
+	"encoding/gob"
+	"io/ioutil"
+	"net/textproto"
+	"os"
+	"strconv"
+	"strings"
+	"sync"
+
+	"git.deineagentur.com/DeineAgenturUG/gotext/plurals"
+)
+
+const (
+	// MoMagicLittleEndian encoding
+	MoMagicLittleEndian = 0x950412de
+	// MoMagicBigEndian encoding
+	MoMagicBigEndian = 0xde120495
+
+	// EotSeparator msgctxt and msgid separator
+	EotSeparator = "\x04"
+	// NulSeparator msgid and msgstr separator
+	NulSeparator = "\x00"
+)
+
+/*
+Mo parses the content of any MO file and provides all the Translation functions needed.
+It's the base object used by all package methods.
+And it's safe for concurrent use by multiple goroutines by using the sync package for locking.
+
+Example:
+
+	import (
+		"fmt"
+		"git.deineagentur.com/DeineAgenturUG/gotext"
+	)
+
+	func main() {
+		// Create po object
+		po := gotext.NewMoTranslator()
+
+		// Parse .po file
+		po.ParseFile("/path/to/po/file/translations.mo")
+
+		// Get Translation
+		fmt.Println(po.Get("Translate this"))
+	}
+
+*/
+type Mo struct {
+	// Headers storage
+	Headers textproto.MIMEHeader
+
+	// Language header
+	Language string
+
+	// Plural-Forms header
+	PluralForms string
+
+	// Parsed Plural-Forms header values
+	nplurals    int
+	plural      string
+	pluralforms plurals.Expression
+
+	// Storage
+	translations map[string]*Translation
+	contexts     map[string]map[string]*Translation
+
+	// Sync Mutex
+	sync.RWMutex
+
+	// Parsing buffers
+	trBuffer  *Translation
+	ctxBuffer string
+}
+
+// NewMoTranslator creates a new Mo object with the Translator interface
+func NewMoTranslator() Translator {
+	return new(Mo)
+}
+
+// ParseFile tries to read the file by its provided path (f) and parse its content as a .po file.
+func (mo *Mo) ParseFile(f string) {
+	// Check if file exists
+	info, err := os.Stat(f)
+	if err != nil {
+		return
+	}
+
+	// Check that isn't a directory
+	if info.IsDir() {
+		return
+	}
+
+	// Parse file content
+	data, err := ioutil.ReadFile(f)
+	if err != nil {
+		return
+	}
+
+	mo.Parse(data)
+}
+
+// Parse loads the translations specified in the provided string (str)
+func (mo *Mo) Parse(buf []byte) {
+	// Lock while parsing
+	mo.Lock()
+
+	// Init storage
+	if mo.translations == nil {
+		mo.translations = make(map[string]*Translation)
+		mo.contexts = make(map[string]map[string]*Translation)
+	}
+
+	r := bytes.NewReader(buf)
+
+	var magicNumber uint32
+	if err := binary.Read(r, binary.LittleEndian, &magicNumber); err != nil {
+		return
+		// return fmt.Errorf("gettext: %v", err)
+	}
+	var bo binary.ByteOrder
+	switch magicNumber {
+	case MoMagicLittleEndian:
+		bo = binary.LittleEndian
+	case MoMagicBigEndian:
+		bo = binary.BigEndian
+	default:
+		return
+		// return fmt.Errorf("gettext: %v", "invalid magic number")
+	}
+
+	var header struct {
+		MajorVersion uint16
+		MinorVersion uint16
+		MsgIDCount   uint32
+		MsgIDOffset  uint32
+		MsgStrOffset uint32
+		HashSize     uint32
+		HashOffset   uint32
+	}
+	if err := binary.Read(r, bo, &header); err != nil {
+		return
+		// return fmt.Errorf("gettext: %v", err)
+	}
+	if v := header.MajorVersion; v != 0 && v != 1 {
+		return
+		// return fmt.Errorf("gettext: %v", "invalid version number")
+	}
+	if v := header.MinorVersion; v != 0 && v != 1 {
+		return
+		// return fmt.Errorf("gettext: %v", "invalid version number")
+	}
+
+	msgIDStart := make([]uint32, header.MsgIDCount)
+	msgIDLen := make([]uint32, header.MsgIDCount)
+	if _, err := r.Seek(int64(header.MsgIDOffset), 0); err != nil {
+		return
+		// return fmt.Errorf("gettext: %v", err)
+	}
+	for i := 0; i < int(header.MsgIDCount); i++ {
+		if err := binary.Read(r, bo, &msgIDLen[i]); err != nil {
+			return
+			// return fmt.Errorf("gettext: %v", err)
+		}
+		if err := binary.Read(r, bo, &msgIDStart[i]); err != nil {
+			return
+			// return fmt.Errorf("gettext: %v", err)
+		}
+	}
+
+	msgStrStart := make([]int32, header.MsgIDCount)
+	msgStrLen := make([]int32, header.MsgIDCount)
+	if _, err := r.Seek(int64(header.MsgStrOffset), 0); err != nil {
+		return
+		// return fmt.Errorf("gettext: %v", err)
+	}
+	for i := 0; i < int(header.MsgIDCount); i++ {
+		if err := binary.Read(r, bo, &msgStrLen[i]); err != nil {
+			return
+			// return fmt.Errorf("gettext: %v", err)
+		}
+		if err := binary.Read(r, bo, &msgStrStart[i]); err != nil {
+			return
+			// return fmt.Errorf("gettext: %v", err)
+		}
+	}
+
+	for i := 0; i < int(header.MsgIDCount); i++ {
+		if _, err := r.Seek(int64(msgIDStart[i]), 0); err != nil {
+			return
+			// return fmt.Errorf("gettext: %v", err)
+		}
+		msgIDData := make([]byte, msgIDLen[i])
+		if _, err := r.Read(msgIDData); err != nil {
+			return
+			// return fmt.Errorf("gettext: %v", err)
+		}
+
+		if _, err := r.Seek(int64(msgStrStart[i]), 0); err != nil {
+			return
+			// return fmt.Errorf("gettext: %v", err)
+		}
+		msgStrData := make([]byte, msgStrLen[i])
+		if _, err := r.Read(msgStrData); err != nil {
+			return
+			// return fmt.Errorf("gettext: %v", err)
+		}
+
+		if len(msgIDData) == 0 {
+			mo.addTranslation(msgIDData, msgStrData)
+		} else {
+			mo.addTranslation(msgIDData, msgStrData)
+		}
+	}
+
+	// Unlock to parse headers
+	mo.Unlock()
+
+	// Parse headers
+	mo.parseHeaders()
+	return
+	// return nil
+}
+
+func (mo *Mo) addTranslation(msgid, msgstr []byte) {
+	translation := NewTranslation()
+	var msgctxt []byte
+	var msgidPlural []byte
+
+	d := bytes.Split(msgid, []byte(EotSeparator))
+	if len(d) == 1 {
+		msgid = d[0]
+	} else {
+		msgid, msgctxt = d[1], d[0]
+	}
+
+	dd := bytes.Split(msgid, []byte(NulSeparator))
+	if len(dd) > 1 {
+		msgid = dd[0]
+		dd = dd[1:]
+	}
+
+	translation.ID = string(msgid)
+
+	msgidPlural = bytes.Join(dd, []byte(NulSeparator))
+	if len(msgidPlural) > 0 {
+		translation.PluralID = string(msgidPlural)
+	}
+
+	ddd := bytes.Split(msgstr, []byte(NulSeparator))
+	if len(ddd) > 0 {
+		for i, s := range ddd {
+			translation.Trs[i] = string(s)
+		}
+	}
+
+	if len(msgctxt) > 0 {
+		// With context...
+		if _, ok := mo.contexts[string(msgctxt)]; !ok {
+			mo.contexts[string(msgctxt)] = make(map[string]*Translation)
+		}
+		mo.contexts[string(msgctxt)][translation.ID] = translation
+	} else {
+		mo.translations[translation.ID] = translation
+	}
+}
+
+// parseHeaders retrieves data from previously parsed headers
+func (mo *Mo) parseHeaders() {
+	// Make sure we end with 2 carriage returns.
+	raw := mo.Get("") + "\n\n"
+
+	// Read
+	reader := bufio.NewReader(strings.NewReader(raw))
+	tp := textproto.NewReader(reader)
+
+	var err error
+
+	// Sync Headers write.
+	mo.Lock()
+	defer mo.Unlock()
+
+	mo.Headers, err = tp.ReadMIMEHeader()
+	if err != nil {
+		return
+	}
+
+	// Get/save needed headers
+	mo.Language = mo.Headers.Get("Language")
+	mo.PluralForms = mo.Headers.Get("Plural-Forms")
+
+	// Parse Plural-Forms formula
+	if mo.PluralForms == "" {
+		return
+	}
+
+	// Split plural form header value
+	pfs := strings.Split(mo.PluralForms, ";")
+
+	// Parse values
+	for _, i := range pfs {
+		vs := strings.SplitN(i, "=", 2)
+		if len(vs) != 2 {
+			continue
+		}
+
+		switch strings.TrimSpace(vs[0]) {
+		case "nplurals":
+			mo.nplurals, _ = strconv.Atoi(vs[1])
+
+		case "plural":
+			mo.plural = vs[1]
+
+			if expr, err := plurals.Compile(mo.plural); err == nil {
+				mo.pluralforms = expr
+			}
+
+		}
+	}
+}
+
+// pluralForm calculates the plural form index corresponding to n.
+// Returns 0 on error
+func (mo *Mo) pluralForm(n int) int {
+	mo.RLock()
+	defer mo.RUnlock()
+
+	// Failure fallback
+	if mo.pluralforms == nil {
+		/* Use the Germanic plural rule.  */
+		if n == 1 {
+			return 0
+		}
+		return 1
+
+	}
+	return mo.pluralforms.Eval(uint32(n))
+}
+
+// Get retrieves the corresponding Translation for the given string.
+// Supports optional parameters (vars... interface{}) to be inserted on the formatted string using the fmt.Printf syntax.
+func (mo *Mo) Get(str string, vars ...interface{}) string {
+	// Sync read
+	mo.RLock()
+	defer mo.RUnlock()
+
+	if mo.translations != nil {
+		if _, ok := mo.translations[str]; ok {
+			return Printf(mo.translations[str].Get(), vars...)
+		}
+	}
+
+	// Return the same we received by default
+	return Printf(str, vars...)
+}
+
+// GetN retrieves the (N)th plural form of Translation for the given string.
+// Supports optional parameters (vars... interface{}) to be inserted on the formatted string using the fmt.Printf syntax.
+func (mo *Mo) GetN(str, plural string, n int, vars ...interface{}) string {
+	// Sync read
+	mo.RLock()
+	defer mo.RUnlock()
+
+	if mo.translations != nil {
+		if _, ok := mo.translations[str]; ok {
+			return Printf(mo.translations[str].GetN(mo.pluralForm(n)), vars...)
+		}
+	}
+
+	if n == 1 {
+		return Printf(str, vars...)
+	}
+	return Printf(plural, vars...)
+}
+
+// GetC retrieves the corresponding Translation for a given string in the given context.
+// Supports optional parameters (vars... interface{}) to be inserted on the formatted string using the fmt.Printf syntax.
+func (mo *Mo) GetC(str, ctx string, vars ...interface{}) string {
+	// Sync read
+	mo.RLock()
+	defer mo.RUnlock()
+
+	if mo.contexts != nil {
+		if _, ok := mo.contexts[ctx]; ok {
+			if mo.contexts[ctx] != nil {
+				if _, ok := mo.contexts[ctx][str]; ok {
+					return Printf(mo.contexts[ctx][str].Get(), vars...)
+				}
+			}
+		}
+	}
+
+	// Return the string we received by default
+	return Printf(str, vars...)
+}
+
+// GetNC retrieves the (N)th plural form of Translation for the given string in the given context.
+// Supports optional parameters (vars... interface{}) to be inserted on the formatted string using the fmt.Printf syntax.
+func (mo *Mo) GetNC(str, plural string, n int, ctx string, vars ...interface{}) string {
+	// Sync read
+	mo.RLock()
+	defer mo.RUnlock()
+
+	if mo.contexts != nil {
+		if _, ok := mo.contexts[ctx]; ok {
+			if mo.contexts[ctx] != nil {
+				if _, ok := mo.contexts[ctx][str]; ok {
+					return Printf(mo.contexts[ctx][str].GetN(mo.pluralForm(n)), vars...)
+				}
+			}
+		}
+	}
+
+	if n == 1 {
+		return Printf(str, vars...)
+	}
+	return Printf(plural, vars...)
+}
+
+// GetE retrieves the corresponding Translation for the given string.
+// Supports optional parameters (vars... interface{}) to be inserted on the formatted string using the fmt.Printf syntax.
+// The second return value is true iff the string was found.
+func (mo *Mo) GetE(str string, vars ...interface{}) (string, bool) {
+	// Sync read
+	mo.RLock()
+	defer mo.RUnlock()
+
+	if mo.translations != nil {
+		if _, ok := mo.translations[str]; ok {
+			if fmt, ok := mo.translations[str].GetE(); ok {
+				return Printf(fmt, vars...), true
+			}
+		}
+	}
+
+	return "", false
+}
+
+// GetNE retrieves the (N)th plural form of Translation for the given string.
+// Supports optional parameters (vars... interface{}) to be inserted on the formatted string using the fmt.Printf syntax.
+// The second return value is true iff the string was found.
+func (mo *Mo) GetNE(str, plural string, n int, vars ...interface{}) (string, bool) {
+	// Sync read
+	mo.RLock()
+	defer mo.RUnlock()
+
+	if mo.translations != nil {
+		if _, ok := mo.translations[str]; ok {
+			if fmt, ok := mo.translations[str].GetNE(mo.pluralForm(n)); ok {
+				return Printf(fmt, vars...), true
+			}
+		}
+	}
+
+	return "", false
+}
+
+// GetCE retrieves the corresponding Translation for a given string in the given context.
+// Supports optional parameters (vars... interface{}) to be inserted on the formatted string using the fmt.Printf syntax.
+// The second return value is true iff the string was found.
+func (mo *Mo) GetCE(str, ctx string, vars ...interface{}) (string, bool) {
+	// Sync read
+	mo.RLock()
+	defer mo.RUnlock()
+
+	if mo.contexts != nil {
+		if _, ok := mo.contexts[ctx]; ok {
+			if mo.contexts[ctx] != nil {
+				if _, ok := mo.contexts[ctx][str]; ok {
+					if fmt, ok := mo.contexts[ctx][str].GetE(); ok {
+						return Printf(fmt, vars...), true
+					}
+				}
+			}
+		}
+	}
+
+	return "", false
+}
+
+// GetNCE retrieves the (N)th plural form of Translation for the given string in the given context.
+// Supports optional parameters (vars... interface{}) to be inserted on the formatted string using the fmt.Printf syntax.
+// The second return value is true iff the string was found.
+func (mo *Mo) GetNCE(str, plural string, n int, ctx string, vars ...interface{}) (string, bool) {
+	// Sync read
+	mo.RLock()
+	defer mo.RUnlock()
+
+	if mo.contexts != nil {
+		if _, ok := mo.contexts[ctx]; ok {
+			if mo.contexts[ctx] != nil {
+				if _, ok := mo.contexts[ctx][str]; ok {
+					if fmt, ok := mo.contexts[ctx][str].GetNE(mo.pluralForm(n)); ok {
+						return Printf(fmt, vars...), true
+					}
+				}
+			}
+		}
+	}
+
+	return "", false
+}
+
+// MarshalBinary implements encoding.BinaryMarshaler interface
+func (mo *Mo) MarshalBinary() ([]byte, error) {
+	obj := new(TranslatorEncoding)
+	obj.Headers = mo.Headers
+	obj.Language = mo.Language
+	obj.PluralForms = mo.PluralForms
+	obj.Nplurals = mo.nplurals
+	obj.Plural = mo.plural
+	obj.Translations = mo.translations
+	obj.Contexts = mo.contexts
+
+	var buff bytes.Buffer
+	encoder := gob.NewEncoder(&buff)
+	err := encoder.Encode(obj)
+
+	return buff.Bytes(), err
+}
+
+// UnmarshalBinary implements encoding.BinaryUnmarshaler interface
+func (mo *Mo) UnmarshalBinary(data []byte) error {
+	buff := bytes.NewBuffer(data)
+	obj := new(TranslatorEncoding)
+
+	decoder := gob.NewDecoder(buff)
+	err := decoder.Decode(obj)
+	if err != nil {
+		return err
+	}
+
+	mo.Headers = obj.Headers
+	mo.Language = obj.Language
+	mo.PluralForms = obj.PluralForms
+	mo.nplurals = obj.Nplurals
+	mo.plural = obj.Plural
+	mo.translations = obj.Translations
+	mo.contexts = obj.Contexts
+
+	if expr, err := plurals.Compile(mo.plural); err == nil {
+		mo.pluralforms = expr
+	}
+
+	return nil
+}

mo_test.go

@@ -0,0 +1,234 @@
+/*
+ * Copyright (c) 2018 DeineAgentur UG https://www.deineagentur.com. All rights reserved.
+ * Licensed under the MIT License. See LICENSE file in the project root for full license information.
+ */
+
+package gotext
+
+import (
+	"os"
+	"path"
+	"testing"
+)
+
+func TestMo_Get(t *testing.T) {
+
+	// Create po object
+	mo := new(Mo)
+
+	// Try to parse a directory
+	mo.ParseFile(path.Clean(os.TempDir()))
+
+	// Parse file
+	mo.ParseFile("fixtures/en_US/default.mo")
+
+	// Test translations
+	tr := mo.Get("My text")
+	if tr != "Translated text" {
+		t.Errorf("Expected 'Translated text' but got '%s'", tr)
+	}
+	// Test translations
+	tr = mo.Get("language")
+	if tr != "en_US" {
+		t.Errorf("Expected 'en_US' but got '%s'", tr)
+	}
+}
+
+func TestMo(t *testing.T) {
+
+	// Create po object
+	mo := new(Mo)
+
+	// Try to parse a directory
+	mo.ParseFile(path.Clean(os.TempDir()))
+
+	// Parse file
+	mo.ParseFile("fixtures/en_US/default.mo")
+
+	// Test translations
+	tr := mo.Get("My text")
+	if tr != "Translated text" {
+		t.Errorf("Expected 'Translated text' but got '%s'", tr)
+	}
+
+	v := "Variable"
+	tr = mo.Get("One with var: %s", v)
+	if tr != "This one is the singular: Variable" {
+		t.Errorf("Expected 'This one is the singular: Variable' but got '%s'", tr)
+	}
+
+	// Test multi-line id
+	tr = mo.Get("multilineid")
+	if tr != "id with multiline content" {
+		t.Errorf("Expected 'id with multiline content' but got '%s'", tr)
+	}
+
+	// Test multi-line plural id
+	tr = mo.Get("multilinepluralid")
+	if tr != "plural id with multiline content" {
+		t.Errorf("Expected 'plural id with multiline content' but got '%s'", tr)
+	}
+
+	// Test multi-line
+	tr = mo.Get("Multi-line")
+	if tr != "Multi line" {
+		t.Errorf("Expected 'Multi line' but got '%s'", tr)
+	}
+
+	// Test plural
+	tr = mo.GetN("One with var: %s", "Several with vars: %s", 2, v)
+	if tr != "This one is the plural: Variable" {
+		t.Errorf("Expected 'This one is the plural: Variable' but got '%s'", tr)
+	}
+
+	// Test not existent translations
+	tr = mo.Get("This is a test")
+	if tr != "This is a test" {
+		t.Errorf("Expected 'This is a test' but got '%s'", tr)
+	}
+
+	tr = mo.GetN("This is a test", "This are tests", 100)
+	if tr != "This are tests" {
+		t.Errorf("Expected 'This are tests' but got '%s'", tr)
+	}
+
+	// Test context translations
+	v = "Test"
+	tr = mo.GetC("One with var: %s", "Ctx", v)
+	if tr != "This one is the singular in a Ctx context: Test" {
+		t.Errorf("Expected 'This one is the singular in a Ctx context: Test' but got '%s'", tr)
+	}
+
+	// Test plural
+	tr = mo.GetNC("One with var: %s", "Several with vars: %s", 17, "Ctx", v)
+	if tr != "This one is the plural in a Ctx context: Test" {
+		t.Errorf("Expected 'This one is the plural in a Ctx context: Test' but got '%s'", tr)
+	}
+
+	// Test default plural vs singular return responses
+	tr = mo.GetN("Original", "Original plural", 4)
+	if tr != "Original plural" {
+		t.Errorf("Expected 'Original plural' but got '%s'", tr)
+	}
+	tr = mo.GetN("Original", "Original plural", 1)
+	if tr != "Original" {
+		t.Errorf("Expected 'Original' but got '%s'", tr)
+	}
+
+	// Test empty Translation strings
+	tr = mo.Get("Empty Translation")
+	if tr != "Empty Translation" {
+		t.Errorf("Expected 'Empty Translation' but got '%s'", tr)
+	}
+
+	tr = mo.Get("Empty plural form singular")
+	if tr != "Singular translated" {
+		t.Errorf("Expected 'Singular translated' but got '%s'", tr)
+	}
+
+	tr = mo.GetN("Empty plural form singular", "Empty plural form", 1)
+	if tr != "Singular translated" {
+		t.Errorf("Expected 'Singular translated' but got '%s'", tr)
+	}
+
+	tr = mo.GetN("Empty plural form singular", "Empty plural form", 2)
+	if tr != "Empty plural form" {
+		t.Errorf("Expected 'Empty plural form' but got '%s'", tr)
+	}
+
+	// Test last Translation
+	tr = mo.Get("More")
+	if tr != "More translation" {
+		t.Errorf("Expected 'More translation' but got '%s'", tr)
+	}
+}
+
+func TestMoRace(t *testing.T) {
+
+	// Create Po object
+	mo := new(Mo)
+
+	// Create sync channels
+	pc := make(chan bool)
+	rc := make(chan bool)
+
+	// Parse po content in a goroutine
+	go func(mo *Mo, done chan bool) {
+		// Parse file
+		mo.ParseFile("fixtures/en_US/default.mo")
+		done <- true
+	}(mo, pc)
+
+	// Read some Translation on a goroutine
+	go func(mo *Mo, done chan bool) {
+		mo.Get("My text")
+		done <- true
+	}(mo, rc)
+
+	// Read something at top level
+	mo.Get("My text")
+
+	// Wait for goroutines to finish
+	<-pc
+	<-rc
+}
+
+func TestNewMoTranslatorRace(t *testing.T) {
+
+	// Create Po object
+	mo := NewMoTranslator()
+
+	// Create sync channels
+	pc := make(chan bool)
+	rc := make(chan bool)
+
+	// Parse po content in a goroutine
+	go func(mo Translator, done chan bool) {
+		// Parse file
+		mo.ParseFile("fixtures/en_US/default.mo")
+		done <- true
+	}(mo, pc)
+
+	// Read some Translation on a goroutine
+	go func(mo Translator, done chan bool) {
+		mo.Get("My text")
+		done <- true
+	}(mo, rc)
+
+	// Read something at top level
+	mo.Get("My text")
+
+	// Wait for goroutines to finish
+	<-pc
+	<-rc
+}
+
+func TestMoBinaryEncoding(t *testing.T) {
+	// Create mo objects
+	mo := new(Mo)
+	mo2 := new(Mo)
+
+	// Parse file
+	mo.ParseFile("fixtures/en_US/default.mo")
+
+	buff, err := mo.MarshalBinary()
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	err = mo2.UnmarshalBinary(buff)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	// Test translations
+	tr := mo2.Get("My text")
+	if tr != "Translated text" {
+		t.Errorf("Expected 'Translated text' but got '%s'", tr)
+	}
+	// Test translations
+	tr = mo2.Get("language")
+	if tr != "en_US" {
+		t.Errorf("Expected 'en_US' but got '%s'", tr)
+	}
+}

plurals/compiler.go

@@ -0,0 +1,429 @@
+/*
+ * Copyright (c) 2018 DeineAgentur UG https://www.deineagentur.com. All rights reserved.
+ * Licensed under the MIT License. See LICENSE file in the project root for full license information.
+ */
+
+/*
+ Package plurals is the pluralform compiler to get the correct translation id of the plural string
+*/
+package plurals
+
+import (
+	"errors"
+	"fmt"
+	"regexp"
+	"strconv"
+	"strings"
+)
+
+type match struct {
+	openPos  int
+	closePos int
+}
+
+var pat = regexp.MustCompile(`(\?|:|\|\||&&|==|!=|>=|>|<=|<|%|\d+|n)`)
+
+type testToken interface {
+	compile(tokens []string) (test test, err error)
+}
+
+type cmpTestBuilder func(val uint32, flipped bool) test
+type logicTestBuild func(left test, right test) test
+
+var ternaryToken ternaryStruct
+
+type ternaryStruct struct{}
+
+func (ternaryStruct) compile(tokens []string) (expr Expression, err error) {
+	main, err := splitTokens(tokens, "?")
+	if err != nil {
+		return expr, err
+	}
+	test, err := compileTest(strings.Join(main.Left, ""))
+	if err != nil {
+		return expr, err
+	}
+	actions, err := splitTokens(main.Right, ":")
+	if err != nil {
+		return expr, err
+	}
+	trueAction, err := compileExpression(strings.Join(actions.Left, ""))
+	if err != nil {
+		return expr, err
+	}
+	falseAction, err := compileExpression(strings.Join(actions.Right, ""))
+	if err != nil {
+		return expr, nil
+	}
+	return ternary{
+		test:      test,
+		trueExpr:  trueAction,
+		falseExpr: falseAction,
+	}, nil
+}
+
+var constToken constValStruct
+
+type constValStruct struct{}
+
+func (constValStruct) compile(tokens []string) (expr Expression, err error) {
+	if len(tokens) == 0 {
+		return expr, errors.New("got nothing instead of constant")
+	}
+	if len(tokens) != 1 {
+		return expr, fmt.Errorf("invalid constant: %s", strings.Join(tokens, ""))
+	}
+	i, err := strconv.Atoi(tokens[0])
+	if err != nil {
+		return expr, err
+	}
+	return constValue{value: i}, nil
+}
+
+func compileLogicTest(tokens []string, sep string, builder logicTestBuild) (test test, err error) {
+	split, err := splitTokens(tokens, sep)
+	if err != nil {
+		return test, err
+	}
+	left, err := compileTest(strings.Join(split.Left, ""))
+	if err != nil {
+		return test, err
+	}
+	right, err := compileTest(strings.Join(split.Right, ""))
+	if err != nil {
+		return test, err
+	}
+	return builder(left, right), nil
+}
+
+var orToken orStruct
+
+type orStruct struct{}
+
+func (orStruct) compile(tokens []string) (test test, err error) {
+	return compileLogicTest(tokens, "||", buildOr)
+}
+func buildOr(left test, right test) test {
+	return or{left: left, right: right}
+}
+
+var andToken andStruct
+
+type andStruct struct{}
+
+func (andStruct) compile(tokens []string) (test test, err error) {
+	return compileLogicTest(tokens, "&&", buildAnd)
+}
+func buildAnd(left test, right test) test {
+	return and{left: left, right: right}
+}
+
+func compileMod(tokens []string) (math math, err error) {
+	split, err := splitTokens(tokens, "%")
+	if err != nil {
+		return math, err
+	}
+	if len(split.Left) != 1 || split.Left[0] != "n" {
+		return math, errors.New("Modulus operation requires 'n' as left operand")
+	}
+	if len(split.Right) != 1 {
+		return math, errors.New("Modulus operation requires simple integer as right operand")
+	}
+	i, err := parseUint32(split.Right[0])
+	if err != nil {
+		return math, err
+	}
+	return mod{value: uint32(i)}, nil
+}
+
+func subPipe(modTokens []string, actionTokens []string, builder cmpTestBuilder, flipped bool) (test test, err error) {
+	modifier, err := compileMod(modTokens)
+	if err != nil {
+		return test, err
+	}
+	if len(actionTokens) != 1 {
+		return test, errors.New("can only get modulus of integer")
+	}
+	i, err := parseUint32(actionTokens[0])
+	if err != nil {
+		return test, err
+	}
+	action := builder(uint32(i), flipped)
+	return pipe{
+		modifier: modifier,
+		action:   action,
+	}, nil
+}
+
+func compileEquality(tokens []string, sep string, builder cmpTestBuilder) (test test, err error) {
+	split, err := splitTokens(tokens, sep)
+	if err != nil {
+		return test, err
+	}
+	if len(split.Left) == 1 && split.Left[0] == "n" {
+		if len(split.Right) != 1 {
+			return test, errors.New("test can only compare n to integers")
+		}
+		i, err := parseUint32(split.Right[0])
+		if err != nil {
+			return test, err
+		}
+		return builder(i, false), nil
+	} else if len(split.Right) == 1 && split.Right[0] == "n" {
+		if len(split.Left) != 1 {
+			return test, errors.New("test can only compare n to integers")
+		}
+		i, err := parseUint32(split.Left[0])
+		if err != nil {
+			return test, err
+		}
+		return builder(i, true), nil
+	} else if contains(split.Left, "n") && contains(split.Left, "%") {
+		return subPipe(split.Left, split.Right, builder, false)
+	}
+	return test, errors.New("equality test must have 'n' as one of the two tests")
+
+}
+
+var eqToken eqStruct
+
+type eqStruct struct{}
+
+func (eqStruct) compile(tokens []string) (test test, err error) {
+	return compileEquality(tokens, "==", buildEq)
+}
+func buildEq(val uint32, flipped bool) test {
+	return equal{value: val}
+}
+
+var neqToken neqStruct
+
+type neqStruct struct{}
+
+func (neqStruct) compile(tokens []string) (test test, err error) {
+	return compileEquality(tokens, "!=", buildNeq)
+}
+func buildNeq(val uint32, flipped bool) test {
+	return notequal{value: val}
+}
+
+var gtToken gtStruct
+
+type gtStruct struct{}
+
+func (gtStruct) compile(tokens []string) (test test, err error) {
+	return compileEquality(tokens, ">", buildGt)
+}
+func buildGt(val uint32, flipped bool) test {
+	return gt{value: val, flipped: flipped}
+}
+
+var gteToken gteStruct
+
+type gteStruct struct{}
+
+func (gteStruct) compile(tokens []string) (test test, err error) {
+	return compileEquality(tokens, ">=", buildGte)
+}
+func buildGte(val uint32, flipped bool) test {
+	return gte{value: val, flipped: flipped}
+}
+
+var ltToken ltStruct
+
+type ltStruct struct{}
+
+func (ltStruct) compile(tokens []string) (test test, err error) {
+	return compileEquality(tokens, "<", buildLt)
+}
+func buildLt(val uint32, flipped bool) test {
+	return lt{value: val, flipped: flipped}
+}
+
+var lteToken lteStruct
+
+type lteStruct struct{}
+
+func (lteStruct) compile(tokens []string) (test test, err error) {
+	return compileEquality(tokens, "<=", buildLte)
+}
+func buildLte(val uint32, flipped bool) test {
+	return lte{value: val, flipped: flipped}
+}
+
+type testTokenDef struct {
+	op    string
+	token testToken
+}
+
+var precedence = []testTokenDef{
+	{op: "||", token: orToken},
+	{op: "&&", token: andToken},
+	{op: "==", token: eqToken},
+	{op: "!=", token: neqToken},
+	{op: ">=", token: gteToken},
+	{op: ">", token: gtToken},
+	{op: "<=", token: lteToken},
+	{op: "<", token: ltToken},
+}
+
+type splitted struct {
+	Left  []string
+	Right []string
+}
+
+// Find index of token in list of tokens
+func index(tokens []string, sep string) int {
+	for index, token := range tokens {
+		if token == sep {
+			return index
+		}
+	}
+	return -1
+}
+
+// Split a list of tokens by a token into a splitted struct holding the tokens
+// before and after the token to be split by.
+func splitTokens(tokens []string, sep string) (s splitted, err error) {
+	index := index(tokens, sep)
+	if index == -1 {
+		return s, fmt.Errorf("'%s' not found in ['%s']", sep, strings.Join(tokens, "','"))
+	}
+	return splitted{
+		Left:  tokens[:index],
+		Right: tokens[index+1:],
+	}, nil
+}
+
+// Scan a string for parenthesis
+func scan(s string) <-chan match {
+	ch := make(chan match)
+	go func() {
+		depth := 0
+		opener := 0
+		for index, char := range s {
+			switch char {
+			case '(':
+				if depth == 0 {
+					opener = index
+				}
+				depth++
+			case ')':
+				depth--
+				if depth == 0 {
+					ch <- match{
+						openPos:  opener,
+						closePos: index + 1,
+					}
+				}
+			}
+
+		}
+		close(ch)
+	}()
+	return ch
+}
+
+// Split the string into tokens
+func split(s string) <-chan string {
+	ch := make(chan string)
+	go func() {
+		s = strings.Replace(s, " ", "", -1)
+		if !strings.Contains(s, "(") {
+			ch <- s
+		} else {
+			last := 0
+			end := len(s)
+			for info := range scan(s) {
+				if last != info.openPos {
+					ch <- s[last:info.openPos]
+				}
+				ch <- s[info.openPos:info.closePos]
+				last = info.closePos
+			}
+			if last != end {
+				ch <- s[last:]
+			}
+		}
+		close(ch)
+	}()
+	return ch
+}
+
+// Tokenizes a string into a list of strings, tokens grouped by parenthesis are
+// not split! If the string starts with ( and ends in ), those are stripped.
+func tokenize(s string) []string {
+	/*
+		TODO: Properly detect if the string starts with a ( and ends with a )
+		and that those two form a matching pair.
+
+		Eg: (foo) -> true; (foo)(bar) -> false;
+	*/
+	if s[0] == '(' && s[len(s)-1] == ')' {
+		s = s[1 : len(s)-1]
+	}
+	ret := []string{}
+	for chunk := range split(s) {
+		if len(chunk) != 0 {
+			if chunk[0] == '(' && chunk[len(chunk)-1] == ')' {
+				ret = append(ret, chunk)
+			} else {
+				for _, token := range pat.FindAllStringSubmatch(chunk, -1) {
+					ret = append(ret, token[0])
+				}
+			}
+		} else {
+			fmt.Printf("Empty chunk in string '%s'\n", s)
+		}
+	}
+	return ret
+}
+
+// Compile a string containing a plural form expression to a Expression object.
+func Compile(s string) (expr Expression, err error) {
+	if s == "0" {
+		return constValue{value: 0}, nil
+	}
+	if !strings.Contains(s, "?") {
+		s += "?1:0"
+	}
+	return compileExpression(s)
+}
+
+// Check if a token is in a slice of strings
+func contains(haystack []string, needle string) bool {
+	for _, s := range haystack {
+		if s == needle {
+			return true
+		}
+	}
+	return false
+}
+
+// Compiles an expression (ternary or constant)
+func compileExpression(s string) (expr Expression, err error) {
+	tokens := tokenize(s)
+	if contains(tokens, "?") {
+		return ternaryToken.compile(tokens)
+	}
+	return constToken.compile(tokens)
+}
+
+// Compiles a test (comparison)
+func compileTest(s string) (test test, err error) {
+	tokens := tokenize(s)
+	for _, tokenDef := range precedence {
+		if contains(tokens, tokenDef.op) {
+			return tokenDef.token.compile(tokens)
+		}
+	}
+	return test, errors.New("cannot compile")
+}
+
+func parseUint32(s string) (ui uint32, err error) {
+	i, err := strconv.ParseUint(s, 10, 32)
+	if err != nil {
+		return ui, err
+	}
+	return uint32(i), nil
+}

plurals/compiler_test.go

@@ -0,0 +1,50 @@
+/*
+ * Copyright (c) 2018 DeineAgentur UG https://www.deineagentur.com. All rights reserved.
+ * Licensed under the MIT License. See LICENSE file in the project root for full license information.
+ */
+
+package plurals
+
+import (
+	"encoding/json"
+	"os"
+	"testing"
+)
+
+type fixture struct {
+	PluralForm string
+	Fixture    []int
+}
+
+func TestCompiler(t *testing.T) {
+	f, err := os.Open("testdata/pluralforms.json")
+	if err != nil {
+		t.Fatal(err)
+	}
+	dec := json.NewDecoder(f)
+	var fixtures []fixture
+	err = dec.Decode(&fixtures)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, data := range fixtures {
+		expr, err := Compile(data.PluralForm)
+		if err != nil {
+			t.Errorf("'%s' triggered error: %s", data.PluralForm, err)
+		} else if expr == nil {
+			t.Logf("'%s' compiled to nil", data.PluralForm)
+			t.Fail()
+		} else {
+			for n, e := range data.Fixture {
+				i := expr.Eval(uint32(n))
+				if i != e {
+					t.Logf("'%s' with n = %d, expected %d, got %d, compiled to %s", data.PluralForm, n, e, i, expr)
+					t.Fail()
+				}
+				if i == -1 {
+					break
+				}
+			}
+		}
+	}
+}

plurals/expression.go

@@ -0,0 +1,43 @@
+/*
+ * Copyright (c) 2018 DeineAgentur UG https://www.deineagentur.com. All rights reserved.
+ * Licensed under the MIT License. See LICENSE file in the project root for full license information.
+ */
+
+package plurals
+
+// Expression is a plurals expression. Eval evaluates the expression for
+// a given n value. Use plurals.Compile to generate Expression instances.
+type Expression interface {
+	Eval(n uint32) int
+}
+
+type constValue struct {
+	value int
+}
+
+func (c constValue) Eval(n uint32) int {
+	return c.value
+}
+
+type test interface {
+	test(n uint32) bool
+}
+
+type ternary struct {
+	test      test
+	trueExpr  Expression
+	falseExpr Expression
+}
+
+func (t ternary) Eval(n uint32) int {
+	if t.test.test(n) {
+		if t.trueExpr == nil {
+			return -1
+		}
+		return t.trueExpr.Eval(n)
+	}
+	if t.falseExpr == nil {
+		return -1
+	}
+	return t.falseExpr.Eval(n)
+}

plurals/math.go

@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2018 DeineAgentur UG https://www.deineagentur.com. All rights reserved.
+ * Licensed under the MIT License. See LICENSE file in the project root for full license information.
+ */
+
+package plurals
+
+type math interface {
+	calc(n uint32) uint32
+}
+
+type mod struct {
+	value uint32
+}
+
+func (m mod) calc(n uint32) uint32 {
+	return n % m.value
+}

plurals/tests.go

@@ -0,0 +1,104 @@
+/*
+ * Copyright (c) 2018 DeineAgentur UG https://www.deineagentur.com. All rights reserved.
+ * Licensed under the MIT License. See LICENSE file in the project root for full license information.
+ */
+
+package plurals
+
+type equal struct {
+	value uint32
+}
+
+func (e equal) test(n uint32) bool {
+	return n == e.value
+}
+
+type notequal struct {
+	value uint32
+}
+
+func (e notequal) test(n uint32) bool {
+	return n != e.value
+}
+
+type gt struct {
+	value   uint32
+	flipped bool
+}
+
+func (e gt) test(n uint32) bool {
+	if e.flipped {
+		return e.value > n
+	} else {
+		return n > e.value
+	}
+}
+
+type lt struct {
+	value   uint32
+	flipped bool
+}
+
+func (e lt) test(n uint32) bool {
+	if e.flipped {
+		return e.value < n
+	}
+	return n < e.value
+}
+
+type gte struct {
+	value   uint32
+	flipped bool
+}
+
+func (e gte) test(n uint32) bool {
+	if e.flipped {
+		return e.value >= n
+	}
+	return n >= e.value
+}
+
+type lte struct {
+	value   uint32
+	flipped bool
+}
+
+func (e lte) test(n uint32) bool {
+	if e.flipped {
+		return e.value <= n
+	}
+	return n <= e.value
+}
+
+type and struct {
+	left  test
+	right test
+}
+
+func (e and) test(n uint32) bool {
+	if !e.left.test(n) {
+		return false
+	}
+	return e.right.test(n)
+}
+
+type or struct {
+	left  test
+	right test
+}
+
+func (e or) test(n uint32) bool {
+	if e.left.test(n) {
+		return true
+	}
+	return e.right.test(n)
+}
+
+type pipe struct {
+	modifier math
+	action   test
+}
+
+func (e pipe) test(n uint32) bool {
+	return e.action.test(e.modifier.calc(n))
+}

po.go

@@ -1,74 +1,51 @@
+/*
+ * Copyright (c) 2018 DeineAgentur UG https://www.deineagentur.com. All rights reserved.
+ * Licensed under the MIT License. See LICENSE file in the project root for full license information.
+ */
+
 package gotext
 
 import (
 	"bufio"
-	"fmt"
-	"github.com/mattn/anko/vm"
+	"bytes"
+	"encoding/gob"
 	"io/ioutil"
 	"net/textproto"
 	"os"
 	"strconv"
 	"strings"
 	"sync"
+
+	"git.deineagentur.com/DeineAgenturUG/gotext/plurals"
 )
 
-type translation struct {
-	id       string
-	pluralID string
-	trs      map[int]string
-}
-
-func newTranslation() *translation {
-	tr := new(translation)
-	tr.trs = make(map[int]string)
-
-	return tr
-}
-
-func (t *translation) get() string {
-	// Look for translation index 0
-	if _, ok := t.trs[0]; ok {
-		return t.trs[0]
-	}
-
-	// Return unstranlated id by default
-	return t.id
-}
-
-func (t *translation) getN(n int) string {
-	// Look for translation index
-	if _, ok := t.trs[n]; ok {
-		return t.trs[n]
-	}
-
-	// Return unstranlated plural by default
-	return t.pluralID
-}
-
 /*
-Po parses the content of any PO file and provides all the translation functions needed.
+Po parses the content of any PO file and provides all the Translation functions needed.
 It's the base object used by all package methods.
 And it's safe for concurrent use by multiple goroutines by using the sync package for locking.
 
 Example:
 
-    import "github.com/leonelquinteros/gotext"
+	import (
+		"fmt"
+		"git.deineagentur.com/DeineAgenturUG/gotext"
+	)
 
-    func main() {
-        // Create po object
-        po := new(gotext.Po)
+	func main() {
+		// Create po object
+		po := gotext.NewPoTranslator()
 
-        // Parse .po file
-        po.ParseFile("/path/to/po/file/translations.po")
+		// Parse .po file
+		po.ParseFile("/path/to/po/file/translations.po")
 
-        // Get translation
-        println(po.Get("Translate this"))
-    }
+		// Get Translation
+		fmt.Println(po.Get("Translate this"))
+	}
 
 */
 type Po struct {
-	// Headers
-	RawHeaders string
+	// Headers storage
+	Headers textproto.MIMEHeader
 
 	// Language header
 	Language string
@@ -77,21 +54,37 @@ type Po struct {
 	PluralForms string
 
 	// Parsed Plural-Forms header values
-	nplurals int
-	plural   string
+	nplurals    int
+	plural      string
+	pluralforms plurals.Expression
 
 	// Storage
-	translations map[string]*translation
-	contexts     map[string]map[string]*translation
+	translations map[string]*Translation
+	contexts     map[string]map[string]*Translation
 
 	// Sync Mutex
 	sync.RWMutex
 
 	// Parsing buffers
-	trBuffer  *translation
+	trBuffer  *Translation
 	ctxBuffer string
 }
 
+type parseState int
+
+const (
+	head parseState = iota
+	msgCtxt
+	msgID
+	msgIDPlural
+	msgStr
+)
+
+// NewPoTranslator creates a new Po object with the Translator interface
+func NewPoTranslator() Translator {
+	return new(Po)
+}
+
 // ParseFile tries to read the file by its provided path (f) and parse its content as a .po file.
 func (po *Po) ParseFile(f string) {
 	// Check if file exists
@@ -111,28 +104,28 @@ func (po *Po) ParseFile(f string) {
 		return
 	}
 
-	po.Parse(string(data))
+	po.Parse(data)
 }
 
 // Parse loads the translations specified in the provided string (str)
-func (po *Po) Parse(str string) {
+func (po *Po) Parse(buf []byte) {
 	// Lock while parsing
 	po.Lock()
-	defer po.Unlock()
 
 	// Init storage
 	if po.translations == nil {
-		po.translations = make(map[string]*translation)
-		po.contexts = make(map[string]map[string]*translation)
+		po.translations = make(map[string]*Translation)
+		po.contexts = make(map[string]map[string]*Translation)
 	}
 
 	// Get lines
-	lines := strings.Split(str, "\n")
+	lines := strings.Split(string(buf), "\n")
 
 	// Init buffer
-	po.trBuffer = newTranslation()
+	po.trBuffer = NewTranslation()
 	po.ctxBuffer = ""
 
+	state := head
 	for _, l := range lines {
 		// Trim spaces
 		l = strings.TrimSpace(l)
@@ -145,67 +138,75 @@ func (po *Po) Parse(str string) {
 		// Buffer context and continue
 		if strings.HasPrefix(l, "msgctxt") {
 			po.parseContext(l)
+			state = msgCtxt
 			continue
 		}
 
 		// Buffer msgid and continue
 		if strings.HasPrefix(l, "msgid") && !strings.HasPrefix(l, "msgid_plural") {
 			po.parseID(l)
+			state = msgID
 			continue
 		}
 
 		// Check for plural form
 		if strings.HasPrefix(l, "msgid_plural") {
 			po.parsePluralID(l)
+			state = msgIDPlural
 			continue
 		}
 
-		// Save translation
+		// Save Translation
 		if strings.HasPrefix(l, "msgstr") {
 			po.parseMessage(l)
+			state = msgStr
 			continue
 		}
 
 		// Multi line strings and headers
 		if strings.HasPrefix(l, "\"") && strings.HasSuffix(l, "\"") {
-			po.parseString(l)
+			po.parseString(l, state)
 			continue
 		}
 	}
 
-	// Save last translation buffer.
+	// Save last Translation buffer.
 	po.saveBuffer()
 
+	// Unlock to parse headers
+	po.Unlock()
+
 	// Parse headers
 	po.parseHeaders()
 }
 
-// saveBuffer takes the context and translation buffers
+// saveBuffer takes the context and Translation buffers
 // and saves it on the translations collection
 func (po *Po) saveBuffer() {
-	// If we have something to save...
-	if po.trBuffer.id != "" {
-		// With no context...
-		if po.ctxBuffer == "" {
-			po.translations[po.trBuffer.id] = po.trBuffer
-		} else {
-			// With context...
-			if _, ok := po.contexts[po.ctxBuffer]; !ok {
-				po.contexts[po.ctxBuffer] = make(map[string]*translation)
-			}
-			po.contexts[po.ctxBuffer][po.trBuffer.id] = po.trBuffer
+	// With no context...
+	if po.ctxBuffer == "" {
+		po.translations[po.trBuffer.ID] = po.trBuffer
+	} else {
+		// With context...
+		if _, ok := po.contexts[po.ctxBuffer]; !ok {
+			po.contexts[po.ctxBuffer] = make(map[string]*Translation)
 		}
+		po.contexts[po.ctxBuffer][po.trBuffer.ID] = po.trBuffer
 
-		// Flush buffer
-		po.trBuffer = newTranslation()
-		po.ctxBuffer = ""
+		// Cleanup current context buffer if needed
+		if po.trBuffer.ID != "" {
+			po.ctxBuffer = ""
+		}
 	}
+
+	// Flush Translation buffer
+	po.trBuffer = NewTranslation()
 }
 
 // parseContext takes a line starting with "msgctxt",
-// saves the current translation buffer and creates a new context.
+// saves the current Translation buffer and creates a new context.
 func (po *Po) parseContext(l string) {
-	// Save current translation buffer.
+	// Save current Translation buffer.
 	po.saveBuffer()
 
 	// Buffer context
@@ -213,25 +214,25 @@ func (po *Po) parseContext(l string) {
 }
 
 // parseID takes a line starting with "msgid",
-// saves the current translation and creates a new msgid buffer.
+// saves the current Translation and creates a new msgid buffer.
 func (po *Po) parseID(l string) {
-	// Save current translation buffer.
+	// Save current Translation buffer.
 	po.saveBuffer()
 
 	// Set id
-	po.trBuffer.id, _ = strconv.Unquote(strings.TrimSpace(strings.TrimPrefix(l, "msgid")))
+	po.trBuffer.ID, _ = strconv.Unquote(strings.TrimSpace(strings.TrimPrefix(l, "msgid")))
 }
 
 // parsePluralID saves the plural id buffer from a line starting with "msgid_plural"
 func (po *Po) parsePluralID(l string) {
-	po.trBuffer.pluralID, _ = strconv.Unquote(strings.TrimSpace(strings.TrimPrefix(l, "msgid_plural")))
+	po.trBuffer.PluralID, _ = strconv.Unquote(strings.TrimSpace(strings.TrimPrefix(l, "msgid_plural")))
 }
 
 // parseMessage takes a line starting with "msgstr" and saves it into the current buffer.
 func (po *Po) parseMessage(l string) {
 	l = strings.TrimSpace(strings.TrimPrefix(l, "msgstr"))
 
-	// Check for indexed translation forms
+	// Check for indexed Translation forms
 	if strings.HasPrefix(l, "[") {
 		idx := strings.Index(l, "]")
 		if idx == -1 {
@@ -246,70 +247,85 @@ func (po *Po) parseMessage(l string) {
 			return
 		}
 
-		// Parse translation string
-		po.trBuffer.trs[i], _ = strconv.Unquote(strings.TrimSpace(l[idx+1:]))
+		// Parse Translation string
+		po.trBuffer.Trs[i], _ = strconv.Unquote(strings.TrimSpace(l[idx+1:]))
 
 		// Loop
 		return
 	}
 
-	// Save single translation form under 0 index
-	po.trBuffer.trs[0], _ = strconv.Unquote(l)
+	// Save single Translation form under 0 index
+	po.trBuffer.Trs[0], _ = strconv.Unquote(l)
 }
 
 // parseString takes a well formatted string without prefix
 // and creates headers or attach multi-line strings when corresponding
-func (po *Po) parseString(l string) {
-	// Check for multiline from previously set msgid
-	if po.trBuffer.id != "" {
-		// Append to last translation found
-		uq, _ := strconv.Unquote(l)
-		po.trBuffer.trs[len(po.trBuffer.trs)-1] += uq
+func (po *Po) parseString(l string, state parseState) {
+	clean, _ := strconv.Unquote(l)
+
+	switch state {
+	case msgStr:
+		// Append to last Translation found
+		po.trBuffer.Trs[len(po.trBuffer.Trs)-1] += clean
+
+	case msgID:
+		// Multiline msgid - Append to current id
+		po.trBuffer.ID += clean
+
+	case msgIDPlural:
+		// Multiline msgid - Append to current id
+		po.trBuffer.PluralID += clean
+
+	case msgCtxt:
+		// Multiline context - Append to current context
+		po.ctxBuffer += clean
 
-		return
 	}
-
-	// Otherwise is a header
-	h, err := strconv.Unquote(strings.TrimSpace(l))
-	if err != nil {
-		return
-	}
-
-	po.RawHeaders += h
 }
 
 // isValidLine checks for line prefixes to detect valid syntax.
 func (po *Po) isValidLine(l string) bool {
-	// Skip empty lines
-	if l == "" {
-		return false
-	}
-
 	// Check prefix
-	if !strings.HasPrefix(l, "\"") && !strings.HasPrefix(l, "msgctxt") && !strings.HasPrefix(l, "msgid") && !strings.HasPrefix(l, "msgid_plural") && !strings.HasPrefix(l, "msgstr") {
-		return false
+	valid := []string{
+		"\"",
+		"msgctxt",
+		"msgid",
+		"msgid_plural",
+		"msgstr",
 	}
 
-	return true
+	for _, v := range valid {
+		if strings.HasPrefix(l, v) {
+			return true
+		}
+	}
+
+	return false
 }
 
 // parseHeaders retrieves data from previously parsed headers
 func (po *Po) parseHeaders() {
 	// Make sure we end with 2 carriage returns.
-	po.RawHeaders += "\n\n"
+	raw := po.Get("") + "\n\n"
 
 	// Read
-	reader := bufio.NewReader(strings.NewReader(po.RawHeaders))
+	reader := bufio.NewReader(strings.NewReader(raw))
 	tp := textproto.NewReader(reader)
 
-	mimeHeader, err := tp.ReadMIMEHeader()
+	var err error
+
+	// Sync Headers write.
+	po.Lock()
+	defer po.Unlock()
+
+	po.Headers, err = tp.ReadMIMEHeader()
 	if err != nil {
 		return
 	}
 
 	// Get/save needed headers
-	po.Language = mimeHeader.Get("Language")
-	po.PluralForms = mimeHeader.Get("Plural-Forms")
+	po.Language = po.Headers.Get("Language")
+	po.PluralForms = po.Headers.Get("Plural-Forms")
 
 	// Parse Plural-Forms formula
 	if po.PluralForms == "" {
@@ -332,6 +348,11 @@ func (po *Po) parseHeaders() {
 
 		case "plural":
 			po.plural = vs[1]
+
+			if expr, err := plurals.Compile(po.plural); err == nil {
+				po.pluralforms = expr
+			}
+
 		}
 	}
 }
@@ -342,38 +363,18 @@ func (po *Po) pluralForm(n int) int {
 	po.RLock()
 	defer po.RUnlock()
 
-	// Failsafe
-	if po.nplurals < 1 {
-		return 0
-	}
-	if po.plural == "" {
-		return 0
-	}
-
-	// Init compiler
-	env := vm.NewEnv()
-	env.Define("n", n)
-
-	plural, err := env.Execute(po.plural)
-	if err != nil {
-		return 0
-	}
-	if plural.Type().Name() == "bool" {
-		if plural.Bool() {
-			return 1
+	// Failure fallback
+	if po.pluralforms == nil {
+		/* Use Western plural rule.  */
+		if n == 1 {
+			return 0
 		}
-		// Else
-		return 0
+		return 1
 	}
-
-	if int(plural.Int()) > po.nplurals {
-		return 0
-	}
-
-	return int(plural.Int())
+	return po.pluralforms.Eval(uint32(n))
 }
 
-// Get retrieves the corresponding translation for the given string.
+// Get retrieves the corresponding Translation for the given string.
 // Supports optional parameters (vars... interface{}) to be inserted on the formatted string using the fmt.Printf syntax.
 func (po *Po) Get(str string, vars ...interface{}) string {
 	// Sync read
@@ -382,15 +383,15 @@ func (po *Po) Get(str string, vars ...interface{}) string {
 
 	if po.translations != nil {
 		if _, ok := po.translations[str]; ok {
-			return fmt.Sprintf(po.translations[str].get(), vars...)
+			return Printf(po.translations[str].Get(), vars...)
 		}
 	}
 
 	// Return the same we received by default
-	return fmt.Sprintf(str, vars...)
+	return Printf(str, vars...)
 }
 
-// GetN retrieves the (N)th plural form of translation for the given string.
+// GetN retrieves the (N)th plural form of Translation for the given string.
 // Supports optional parameters (vars... interface{}) to be inserted on the formatted string using the fmt.Printf syntax.
 func (po *Po) GetN(str, plural string, n int, vars ...interface{}) string {
 	// Sync read
@@ -399,15 +400,18 @@ func (po *Po) GetN(str, plural string, n int, vars ...interface{}) string {
 
 	if po.translations != nil {
 		if _, ok := po.translations[str]; ok {
-			return fmt.Sprintf(po.translations[str].getN(po.pluralForm(n)), vars...)
+			return Printf(po.translations[str].GetN(po.pluralForm(n)), vars...)
 		}
 	}
 
-	// Return the plural string we received by default
-	return fmt.Sprintf(plural, vars...)
+	// Parse plural forms to distinguish between plural and singular
+	if po.pluralForm(n) == 0 {
+		return Printf(str, vars...)
+	}
+	return Printf(plural, vars...)
 }
 
-// GetC retrieves the corresponding translation for a given string in the given context.
+// GetC retrieves the corresponding Translation for a given string in the given context.
 // Supports optional parameters (vars... interface{}) to be inserted on the formatted string using the fmt.Printf syntax.
 func (po *Po) GetC(str, ctx string, vars ...interface{}) string {
 	// Sync read
@@ -418,17 +422,17 @@ func (po *Po) GetC(str, ctx string, vars ...interface{}) string {
 		if _, ok := po.contexts[ctx]; ok {
 			if po.contexts[ctx] != nil {
 				if _, ok := po.contexts[ctx][str]; ok {
-					return fmt.Sprintf(po.contexts[ctx][str].get(), vars...)
+					return Printf(po.contexts[ctx][str].Get(), vars...)
 				}
 			}
 		}
 	}
 
 	// Return the string we received by default
-	return fmt.Sprintf(str, vars...)
+	return Printf(str, vars...)
 }
 
-// GetNC retrieves the (N)th plural form of translation for the given string in the given context.
+// GetNC retrieves the (N)th plural form of Translation for the given string in the given context.
 // Supports optional parameters (vars... interface{}) to be inserted on the formatted string using the fmt.Printf syntax.
 func (po *Po) GetNC(str, plural string, n int, ctx string, vars ...interface{}) string {
 	// Sync read
@@ -439,12 +443,144 @@ func (po *Po) GetNC(str, plural string, n int, ctx string, vars ...interface{})
 		if _, ok := po.contexts[ctx]; ok {
 			if po.contexts[ctx] != nil {
 				if _, ok := po.contexts[ctx][str]; ok {
-					return fmt.Sprintf(po.contexts[ctx][str].getN(po.pluralForm(n)), vars...)
+					return Printf(po.contexts[ctx][str].GetN(po.pluralForm(n)), vars...)
 				}
 			}
 		}
 	}
 
-	// Return the plural string we received by default
-	return fmt.Sprintf(plural, vars...)
+	// Parse plural forms to distinguish between plural and singular
+	if po.pluralForm(n) == 0 {
+		return Printf(str, vars...)
+	}
+	return Printf(plural, vars...)
+}
+
+// GetE retrieves the corresponding Translation for the given string.
+// Supports optional parameters (vars... interface{}) to be inserted on the formatted string using the fmt.Printf syntax.
+// The second return value is true iff the string was found.
+func (po *Po) GetE(str string, vars ...interface{}) (string, bool) {
+	// Sync read
+	po.RLock()
+	defer po.RUnlock()
+
+	if po.translations != nil {
+		if _, ok := po.translations[str]; ok {
+			if fmt, ok := po.translations[str].GetE(); ok {
+				return Printf(fmt, vars...), true
+			}
+		}
+	}
+
+	return "", false
+}
+
+// GetNE retrieves the (N)th plural form of Translation for the given string.
+// Supports optional parameters (vars... interface{}) to be inserted on the formatted string using the fmt.Printf syntax.
+// The second return value is true iff the string was found.
+func (po *Po) GetNE(str, plural string, n int, vars ...interface{}) (string, bool) {
+	// Sync read
+	po.RLock()
+	defer po.RUnlock()
+
+	if po.translations != nil {
+		if _, ok := po.translations[str]; ok {
+			if fmt, ok := po.translations[str].GetNE(po.pluralForm(n)); ok {
+				return Printf(fmt, vars...), true
+			}
+		}
+	}
+
+	return "", false
+}
+
+// GetCE retrieves the corresponding Translation for a given string in the given context.
+// Supports optional parameters (vars... interface{}) to be inserted on the formatted string using the fmt.Printf syntax.
+// The second return value is true iff the string was found.
+func (po *Po) GetCE(str, ctx string, vars ...interface{}) (string, bool) {
+	// Sync read
+	po.RLock()
+	defer po.RUnlock()
+
+	if po.contexts != nil {
+		if _, ok := po.contexts[ctx]; ok {
+			if po.contexts[ctx] != nil {
+				if _, ok := po.contexts[ctx][str]; ok {
+					if fmt, ok := po.contexts[ctx][str].GetE(); ok {
+						return Printf(fmt, vars...), true
+					}
+				}
+			}
+		}
+	}
+
+	return "", false
+}
+
+// GetNCE retrieves the (N)th plural form of Translation for the given string in the given context.
+// Supports optional parameters (vars... interface{}) to be inserted on the formatted string using the fmt.Printf syntax.
+// The second return value is true iff the string was found.
+func (po *Po) GetNCE(str, plural string, n int, ctx string, vars ...interface{}) (string, bool) {
+	// Sync read
+	po.RLock()
+	defer po.RUnlock()
+
+	if po.contexts != nil {
+		if _, ok := po.contexts[ctx]; ok {
+			if po.contexts[ctx] != nil {
+				if _, ok := po.contexts[ctx][str]; ok {
+					if fmt, ok := po.contexts[ctx][str].GetNE(po.pluralForm(n)); ok {
+						return Printf(fmt, vars...), true
+					}
+				}
+			}
+		}
+	}
+
+	// Parse plural forms to distinguish between plural and singular
+	return "", false
+}
+
+// MarshalBinary implements encoding.BinaryMarshaler interface
+func (po *Po) MarshalBinary() ([]byte, error) {
+	obj := new(TranslatorEncoding)
+	obj.Headers = po.Headers
+	obj.Language = po.Language
+	obj.PluralForms = po.PluralForms
+	obj.Nplurals = po.nplurals
+	obj.Plural = po.plural
+	obj.Translations = po.translations
+	obj.Contexts = po.contexts
+
+	var buff bytes.Buffer
+	encoder := gob.NewEncoder(&buff)
+	err := encoder.Encode(obj)
+
+	return buff.Bytes(), err
+}
+
+// UnmarshalBinary implements encoding.BinaryUnmarshaler interface
+func (po *Po) UnmarshalBinary(data []byte) error {
+	buff := bytes.NewBuffer(data)
+	obj := new(TranslatorEncoding)
+
+	decoder := gob.NewDecoder(buff)
+	err := decoder.Decode(obj)
+	if err != nil {
+		return err
+	}
+
+	po.Headers = obj.Headers
+	po.Language = obj.Language
+	po.PluralForms = obj.PluralForms
+	po.nplurals = obj.Nplurals
+	po.plural = obj.Plural
+	po.translations = obj.Translations
+	po.contexts = obj.Contexts
+
+	if expr, err := plurals.Compile(po.plural); err == nil {
+		po.pluralforms = expr
+	}
+
+	return nil
 }

po_test.go

@@ -1,3 +1,8 @@
+/*
+ * Copyright (c) 2018 DeineAgentur UG https://www.deineagentur.com. All rights reserved.
+ * Licensed under the MIT License. See LICENSE file in the project root for full license information.
+ */
+
 package gotext
 
 import (
@@ -6,11 +11,34 @@ import (
 	"testing"
 )
 
+func TestPo_Get(t *testing.T) {
+	// Create po object
+	po := new(Po)
+
+	// Try to parse a directory
+	po.ParseFile(path.Clean(os.TempDir()))
+
+	// Parse file
+	po.ParseFile("fixtures/en_US/default.po")
+
+	// Test translations
+	tr := po.Get("My text")
+	if tr != "Translated text" {
+		t.Errorf("Expected 'Translated text' but got '%s'", tr)
+	}
+	// Test translations
+	tr = po.Get("language")
+	if tr != "en_US" {
+		t.Errorf("Expected 'en_US' but got '%s'", tr)
+	}
+}
+
 func TestPo(t *testing.T) {
 	// Set PO content
 	str := `
-msgid ""
-msgstr ""
+msgid   ""
+msgstr  ""
+
 # Initial comment
 # Headers below
 "Language: en\n"
@@ -26,9 +54,25 @@ msgstr "Translated text"
 msgid "Another string"
 msgstr ""
 
+# Multi-line msgid
+msgid ""
+"multi"
+"line"
+"id"
+msgstr "id with multiline content"
+
+# Multi-line msgid_plural
+msgid ""
+"multi"
+"line"
+"plural"
+"id"
+msgstr "plural id with multiline content"
+
 #Multi-line string
 msgid "Multi-line"
-msgstr "Multi "
+msgstr ""
+"Multi "
 "line"
 
 msgid "One with var: %s"
@@ -37,14 +81,6 @@ msgstr[0] "This one is the singular: %s"
 msgstr[1] "This one is the plural: %s"
 msgstr[2] "And this is the second plural form: %s"
 
-msgid "This one has invalid syntax translations"
-msgid_plural "Plural index"
-msgstr[abc] "Wrong index"
-msgstr[1 "Forgot to close brackets"
-msgstr[0] "Badly formatted string'
-
-msgid "Invalid formatted id[] with no translations
-
 msgctxt "Ctx"
 msgid "One with var: %s"
 msgid_plural "Several with vars: %s"
@@ -52,15 +88,24 @@ msgstr[0] "This one is the singular in a Ctx context: %s"
 msgstr[1] "This one is the plural in a Ctx context: %s"
 
 msgid "Some random"
-msgstr "Some random translation"
+msgstr "Some random Translation"
 
 msgctxt "Ctx"
 msgid "Some random in a context"
-msgstr "Some random translation in a context"
+msgstr "Some random Translation in a context"
+
+msgid "Empty Translation"
+msgstr ""
+
+msgid "Empty plural form singular"
+msgid_plural "Empty plural form"
+msgstr[0] "Singular translated"
+msgstr[1] ""
 
 msgid "More"
-msgstr "More translation"
-    `
+msgstr "More Translation"
+
+	`
 
 	// Write PO content to file
 	filename := path.Clean(os.TempDir() + string(os.PathSeparator) + "default.po")
@@ -97,6 +142,18 @@ msgstr "More translation"
 		t.Errorf("Expected 'This one is the singular: Variable' but got '%s'", tr)
 	}
 
+	// Test multi-line id
+	tr = po.Get("multilineid")
+	if tr != "id with multiline content" {
+		t.Errorf("Expected 'id with multiline content' but got '%s'", tr)
+	}
+
+	// Test multi-line plural id
+	tr = po.Get("multilinepluralid")
+	if tr != "plural id with multiline content" {
+		t.Errorf("Expected 'plural id with multiline content' but got '%s'", tr)
+	}
+
 	// Test multi-line
 	tr = po.Get("Multi-line")
 	if tr != "Multi line" {
@@ -109,7 +166,7 @@ msgstr "More translation"
 		t.Errorf("Expected 'This one is the plural: Variable' but got '%s'", tr)
 	}
 
-	// Test inexistent translations
+	// Test not existent translations
 	tr = po.Get("This is a test")
 	if tr != "This is a test" {
 		t.Errorf("Expected 'This is a test' but got '%s'", tr)
@@ -120,17 +177,22 @@ msgstr "More translation"
 		t.Errorf("Expected 'This are tests' but got '%s'", tr)
 	}
 
-	// Test syntax error parsed translations
-	tr = po.Get("This one has invalid syntax translations")
-	if tr != "" {
-		t.Errorf("Expected '' but got '%s'", tr)
+	// Test translations with existence check
+	tr, exists := po.GetE("My text")
+	if (tr != "Translated text") || (!exists) {
+		t.Errorf("Expected 'Translated text', true but got '%s', %v", tr, exists)
+	}
+	
+	tr, exists = po.GetE("I don't exist")
+	if exists {
+		t.Errorf("Expected 'I don't exist' not to exist but got '%s'", tr)
 	}
 
-	tr = po.GetN("This one has invalid syntax translations", "This are tests", 4)
-	if tr != "Plural index" {
-		t.Errorf("Expected 'Plural index' but got '%s'", tr)
+	tr = po.GetN("I don't exist", "We don't exist", 100)
+	if exists {
+		t.Errorf("Expected 'I/We don't exist' not to exist but got '%s'", tr)
 	}
-
+	
 	// Test context translations
 	v = "Test"
 	tr = po.GetC("One with var: %s", "Ctx", v)
@@ -144,19 +206,110 @@ msgstr "More translation"
 		t.Errorf("Expected 'This one is the plural in a Ctx context: Test' but got '%s'", tr)
 	}
 
-	// Test last translation
-	tr = po.Get("More")
-	if tr != "More translation" {
-		t.Errorf("Expected 'More translation' but got '%s'", tr)
+	// Test default plural vs singular return responses
+	tr = po.GetN("Original", "Original plural", 4)
+	if tr != "Original plural" {
+		t.Errorf("Expected 'Original plural' but got '%s'", tr)
+	}
+	tr = po.GetN("Original", "Original plural", 1)
+	if tr != "Original" {
+		t.Errorf("Expected 'Original' but got '%s'", tr)
 	}
 
+	// Test empty Translation strings
+	tr = po.Get("Empty Translation")
+	if tr != "Empty Translation" {
+		t.Errorf("Expected 'Empty Translation' but got '%s'", tr)
+	}
+
+	tr = po.Get("Empty plural form singular")
+	if tr != "Singular translated" {
+		t.Errorf("Expected 'Singular translated' but got '%s'", tr)
+	}
+
+	tr = po.GetN("Empty plural form singular", "Empty plural form", 1)
+	if tr != "Singular translated" {
+		t.Errorf("Expected 'Singular translated' but got '%s'", tr)
+	}
+
+	tr = po.GetN("Empty plural form singular", "Empty plural form", 2)
+	if tr != "Empty plural form" {
+		t.Errorf("Expected 'Empty plural form' but got '%s'", tr)
+	}
+
+	// Test last Translation
+	tr = po.Get("More")
+	if tr != "More Translation" {
+		t.Errorf("Expected 'More Translation' but got '%s'", tr)
+	}
+}
+
+func TestPlural(t *testing.T) {
+	// Set PO content
+	str := `
+msgid   ""
+msgstr  ""
+"Plural-Forms: nplurals=2; plural=(n != 1);\n"
+
+msgid "Singular: %s"
+msgid_plural "Plural: %s"
+msgstr[0] "TR Singular: %s"
+msgstr[1] "TR Plural: %s"
+msgstr[2] "TR Plural 2: %s"
+
+
+`
+	// Create po object
+	po := new(Po)
+	po.Parse([]byte(str))
+
+	v := "Var"
+	tr := po.GetN("Singular: %s", "Plural: %s", 2, v)
+	if tr != "TR Plural: Var" {
+		t.Errorf("Expected 'TR Plural: Var' but got '%s'", tr)
+	}
+
+	tr = po.GetN("Singular: %s", "Plural: %s", 1, v)
+	if tr != "TR Singular: Var" {
+		t.Errorf("Expected 'TR Singular: Var' but got '%s'", tr)
+	}
+}
+
+func TestPluralNoHeaderInformation(t *testing.T) {
+	// Set PO content
+	str := `
+msgid   ""
+msgstr  ""
+
+msgid "Singular: %s"
+msgid_plural "Plural: %s"
+msgstr[0] "TR Singular: %s"
+msgstr[1] "TR Plural: %s"
+msgstr[2] "TR Plural 2: %s"
+
+
+`
+	// Create po object
+	po := new(Po)
+	po.Parse([]byte(str))
+
+	v := "Var"
+	tr := po.GetN("Singular: %s", "Plural: %s", 2, v)
+	if tr != "TR Plural: Var" {
+		t.Errorf("Expected 'TR Plural: Var' but got '%s'", tr)
+	}
+
+	tr = po.GetN("Singular: %s", "Plural: %s", 1, v)
+	if tr != "TR Singular: Var" {
+		t.Errorf("Expected 'TR Singular: Var' but got '%s'", tr)
+	}
 }
 
 func TestPoHeaders(t *testing.T) {
 	// Set PO content
 	str := `
-msgid ""
-msgstr ""
+msgid   ""
+msgstr  ""
 # Initial comment
 # Headers below
 "Language: en\n"
@@ -167,13 +320,13 @@ msgstr ""
 # Some comment
 msgid "Example"
 msgstr "Translated example"
-    `
+	`
 
 	// Create po object
 	po := new(Po)
 
 	// Parse
-	po.Parse(str)
+	po.Parse([]byte(str))
 
 	// Check headers expected
 	if po.Language != "en" {
@@ -186,9 +339,30 @@ msgstr "Translated example"
 	}
 }
 
+func TestMissingPoHeadersSupport(t *testing.T) {
+	// Set PO content
+	str := `
+msgid "Example"
+msgstr "Translated example"
+	`
+
+	// Create po object
+	po := new(Po)
+
+	// Parse
+	po.Parse([]byte(str))
+
+	// Check Translation expected
+	if po.Get("Example") != "Translated example" {
+		t.Errorf("Expected 'Translated example' but got '%s'", po.Get("Example"))
+	}
+}
+
 func TestPluralFormsSingle(t *testing.T) {
 	// Single form
 	str := `
+msgid   ""
+msgstr  ""
 "Plural-Forms: nplurals=1; plural=0;"
 
 # Some comment
@@ -198,13 +372,13 @@ msgstr[0] "Singular form"
 msgstr[1] "Plural form 1"
 msgstr[2] "Plural form 2"
 msgstr[3] "Plural form 3"
-    `
+	`
 
 	// Create po object
 	po := new(Po)
 
 	// Parse
-	po.Parse(str)
+	po.Parse([]byte(str))
 
 	// Check plural form
 	n := po.pluralForm(0)
@@ -232,6 +406,8 @@ msgstr[3] "Plural form 3"
 func TestPluralForms2(t *testing.T) {
 	// 2 forms
 	str := `
+msgid   ""
+msgstr  ""
 "Plural-Forms: nplurals=2; plural=n != 1;"
 
 # Some comment
@@ -241,13 +417,13 @@ msgstr[0] "Singular form"
 msgstr[1] "Plural form 1"
 msgstr[2] "Plural form 2"
 msgstr[3] "Plural form 3"
-    `
+	`
 
 	// Create po object
 	po := new(Po)
 
 	// Parse
-	po.Parse(str)
+	po.Parse([]byte(str))
 
 	// Check plural form
 	n := po.pluralForm(0)
@@ -271,6 +447,8 @@ msgstr[3] "Plural form 3"
 func TestPluralForms3(t *testing.T) {
 	// 3 forms
 	str := `
+msgid   ""
+msgstr  ""
 "Plural-Forms: nplurals=3; plural=n%10==1 && n%100!=11 ? 0 : n != 0 ? 1 : 2;"
 
 # Some comment
@@ -280,13 +458,13 @@ msgstr[0] "Singular form"
 msgstr[1] "Plural form 1"
 msgstr[2] "Plural form 2"
 msgstr[3] "Plural form 3"
-    `
+	`
 
 	// Create po object
 	po := new(Po)
 
 	// Parse
-	po.Parse(str)
+	po.Parse([]byte(str))
 
 	// Check plural form
 	n := po.pluralForm(0)
@@ -318,6 +496,8 @@ msgstr[3] "Plural form 3"
 func TestPluralFormsSpecial(t *testing.T) {
 	// 3 forms special
 	str := `
+msgid   ""
+msgstr  ""
 "Plural-Forms: nplurals=3;"
 "plural=(n==1) ? 0 : (n>=2 && n<=4) ? 1 : 2;"
 
@@ -328,13 +508,13 @@ msgstr[0] "Singular form"
 msgstr[1] "Plural form 1"
 msgstr[2] "Plural form 2"
 msgstr[3] "Plural form 3"
-    `
+	`
 
 	// Create po object
 	po := new(Po)
 
 	// Parse
-	po.Parse(str)
+	po.Parse([]byte(str))
 
 	// Check plural form
 	n := po.pluralForm(1)
@@ -360,19 +540,18 @@ msgstr[3] "Plural form 3"
 }
 
 func TestTranslationObject(t *testing.T) {
-	tr := newTranslation()
-	str := tr.get()
+	tr := NewTranslation()
+	str := tr.Get()
 
 	if str != "" {
 		t.Errorf("Expected '' but got '%s'", str)
 	}
 
 	// Set id
-	tr.id = "Text"
+	tr.ID = "Text"
+	str = tr.Get()
 
 	// Get again
-	str = tr.get()
-
 	if str != "Text" {
 		t.Errorf("Expected 'Text' but got '%s'", str)
 	}
@@ -394,7 +573,7 @@ msgstr[0] "This one is the singular: %s"
 msgstr[1] "This one is the plural: %s"
 msgstr[2] "And this is the second plural form: %s"
 
-    `
+	`
 
 	// Create Po object
 	po := new(Po)
@@ -405,11 +584,11 @@ msgstr[2] "And this is the second plural form: %s"
 
 	// Parse po content in a goroutine
 	go func(po *Po, done chan bool) {
-		po.Parse(str)
+		po.Parse([]byte(str))
 		done <- true
 	}(po, pc)
 
-	// Read some translation on a goroutine
+	// Read some Translation on a goroutine
 	go func(po *Po, done chan bool) {
 		po.Get("My text")
 		done <- true
@@ -422,3 +601,62 @@ msgstr[2] "And this is the second plural form: %s"
 	<-pc
 	<-rc
 }
+
+func TestNewPoTranslatorRace(t *testing.T) {
+	// Create Po object
+	mo := NewPoTranslator()
+
+	// Create sync channels
+	pc := make(chan bool)
+	rc := make(chan bool)
+
+	// Parse po content in a goroutine
+	go func(mo Translator, done chan bool) {
+		// Parse file
+		mo.ParseFile("fixtures/en_US/default.po")
+		done <- true
+	}(mo, pc)
+
+	// Read some Translation on a goroutine
+	go func(mo Translator, done chan bool) {
+		mo.Get("My text")
+		done <- true
+	}(mo, rc)
+
+	// Read something at top level
+	mo.Get("My text")
+
+	// Wait for goroutines to finish
+	<-pc
+	<-rc
+}
+
+func TestPoBinaryEncoding(t *testing.T) {
+	// Create po objects
+	po := new(Po)
+	po2 := new(Po)
+
+	// Parse file
+	po.ParseFile("fixtures/en_US/default.po")
+
+	buff, err := po.MarshalBinary()
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	err = po2.UnmarshalBinary(buff)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	// Test translations
+	tr := po2.Get("My text")
+	if tr != "Translated text" {
+		t.Errorf("Expected 'Translated text' but got '%s'", tr)
+	}
+	// Test translations
+	tr = po2.Get("language")
+	if tr != "en_US" {
+		t.Errorf("Expected 'en_US' but got '%s'", tr)
+	}
+}

translation.go

@@ -0,0 +1,78 @@
+/*
+ * Copyright (c) 2018 DeineAgentur UG https://www.deineagentur.com. All rights reserved.
+ * Licensed under the MIT License. See LICENSE file in the project root for full license information.
+ */
+
+package gotext
+
+// Translation is the struct for the Translations parsed via Po or Mo files and all coming parsers
+type Translation struct {
+	ID       string
+	PluralID string
+	Trs      map[int]string
+}
+
+// NewTranslation returns the Translation object and initialized it.
+func NewTranslation() *Translation {
+	tr := new(Translation)
+	tr.Trs = make(map[int]string)
+
+	return tr
+}
+
+// Get returns the string of the translation
+func (t *Translation) Get() string {
+	// Look for Translation index 0
+	if _, ok := t.Trs[0]; ok {
+		if t.Trs[0] != "" {
+			return t.Trs[0]
+		}
+	}
+
+	// Return untranslated id by default
+	return t.ID
+}
+
+// GetN returns the string of the plural translation
+func (t *Translation) GetN(n int) string {
+	// Look for Translation index
+	if _, ok := t.Trs[n]; ok {
+		if t.Trs[n] != "" {
+			return t.Trs[n]
+		}
+	}
+
+	// Return untranslated singular if corresponding
+	if n == 0 {
+		return t.ID
+	}
+
+	// Return untranslated plural by default
+	return t.PluralID
+}
+
+// GetE returns the string of the translation. The second return value is true
+// iff the string was found.
+func (t *Translation) GetE() (string, bool) {
+	// Look for Translation index 0
+	if _, ok := t.Trs[0]; ok {
+		if t.Trs[0] != "" {
+			return t.Trs[0], true
+		}
+	}
+
+	return "", false
+}
+
+// GetNE returns the string of the plural translation. The second return value
+// is true iff the string was found.
+func (t *Translation) GetNE(n int) (string, bool) {
+	// Look for Translation index
+	if _, ok := t.Trs[n]; ok {
+		if t.Trs[n] != "" {
+			return t.Trs[n], true
+		}
+	}
+
+	return "", false
+}

translator.go

@@ -0,0 +1,65 @@
+/*
+ * Copyright (c) 2018 DeineAgentur UG https://www.deineagentur.com. All rights reserved.
+ * Licensed under the MIT License. See LICENSE file in the project root for full license information.
+ */
+
+package gotext
+
+import "net/textproto"
+
+// Translator interface is used by Locale and Po objects.Translator
+// It contains all methods needed to parse translation sources and obtain corresponding translations.
+// Also implements gob.GobEncoder/gob.DobDecoder interfaces to allow serialization of Locale objects.
+type Translator interface {
+	ParseFile(f string)
+	Parse(buf []byte)
+
+	Get(str string, vars ...interface{}) string
+	GetN(str, plural string, n int, vars ...interface{}) string
+	GetC(str, ctx string, vars ...interface{}) string
+	GetNC(str, plural string, n int, ctx string, vars ...interface{}) string
+
+	GetE(str string, vars ...interface{}) (string, bool)
+	GetNE(str, plural string, n int, vars ...interface{}) (string, bool)
+	GetCE(str, ctx string, vars ...interface{}) (string, bool)
+	GetNCE(str, plural string, n int, ctx string, vars ...interface{}) (string, bool)
+
+	MarshalBinary() ([]byte, error)
+	UnmarshalBinary([]byte) error
+}
+
+// TranslatorEncoding is used as intermediary storage to encode Translator objects to Gob.
+type TranslatorEncoding struct {
+	// Headers storage
+	Headers textproto.MIMEHeader
+
+	// Language header
+	Language string
+
+	// Plural-Forms header
+	PluralForms string
+
+	// Parsed Plural-Forms header values
+	Nplurals int
+	Plural   string
+
+	// Storage
+	Translations map[string]*Translation
+	Contexts     map[string]map[string]*Translation
+}
+
+// GetTranslator is used to recover a Translator object after unmarshaling the TranslatorEncoding object.
+// Internally uses a Po object as it should be switcheable with Mo objects without problem.
+// External Translator implementations should be able to serialize into a TranslatorEncoding object in order to unserialize into a Po-compatible object.
+func (te *TranslatorEncoding) GetTranslator() Translator {
+	po := new(Po)
+	po.Headers = te.Headers
+	po.Language = te.Language
+	po.PluralForms = te.PluralForms
+	po.nplurals = te.Nplurals
+	po.plural = te.Plural
+	po.translations = te.Translations
+	po.contexts = te.Contexts
+
+	return po
+}

vendor/github.com/mattn/anko/ast/doc.go

@@ -1,2 +0,0 @@
-// Package ast implements abstruct-syntax-tree for anko.
-package ast

vendor/github.com/mattn/anko/ast/expr.go

@@ -1,201 +0,0 @@
-package ast
-
-// Expr provides all of interfaces for expression.
-type Expr interface {
-	Pos
-	expr()
-}
-
-// ExprImpl provide commonly implementations for Expr.
-type ExprImpl struct {
-	PosImpl // ExprImpl provide Pos() function.
-}
-
-// expr provide restraint interface.
-func (x *ExprImpl) expr() {}
-
-// NumberExpr provide Number expression.
-type NumberExpr struct {
-	ExprImpl
-	Lit string
-}
-
-// StringExpr provide String expression.
-type StringExpr struct {
-	ExprImpl
-	Lit string
-}
-
-// ArrayExpr provide Array expression.
-type ArrayExpr struct {
-	ExprImpl
-	Exprs []Expr
-}
-
-// PairExpr provide one of Map key/value pair.
-type PairExpr struct {
-	ExprImpl
-	Key   string
-	Value Expr
-}
-
-// MapExpr provide Map expression.
-type MapExpr struct {
-	ExprImpl
-	MapExpr map[string]Expr
-}
-
-// IdentExpr provide identity expression.
-type IdentExpr struct {
-	ExprImpl
-	Lit string
-}
-
-// UnaryExpr provide unary minus expression. ex: -1, ^1, ~1.
-type UnaryExpr struct {
-	ExprImpl
-	Operator string
-	Expr     Expr
-}
-
-// AddrExpr provide referencing address expression.
-type AddrExpr struct {
-	ExprImpl
-	Expr Expr
-}
-
-// DerefExpr provide dereferencing address expression.
-type DerefExpr struct {
-	ExprImpl
-	Expr Expr
-}
-
-// ParenExpr provide parent block expression.
-type ParenExpr struct {
-	ExprImpl
-	SubExpr Expr
-}
-
-// BinOpExpr provide binary operator expression.
-type BinOpExpr struct {
-	ExprImpl
-	Lhs      Expr
-	Operator string
-	Rhs      Expr
-}
-
-type TernaryOpExpr struct {
-	ExprImpl
-	Expr Expr
-	Lhs  Expr
-	Rhs  Expr
-}
-
-// CallExpr provide calling expression.
-type CallExpr struct {
-	ExprImpl
-	Func     interface{}
-	Name     string
-	SubExprs []Expr
-	VarArg   bool
-	Go       bool
-}
-
-// AnonCallExpr provide anonymous calling expression. ex: func(){}().
-type AnonCallExpr struct {
-	ExprImpl
-	Expr     Expr
-	SubExprs []Expr
-	VarArg   bool
-	Go       bool
-}
-
-// MemberExpr provide expression to refer menber.
-type MemberExpr struct {
-	ExprImpl
-	Expr Expr
-	Name string
-}
-
-// ItemExpr provide expression to refer Map/Array item.
-type ItemExpr struct {
-	ExprImpl
-	Value Expr
-	Index Expr
-}
-
-// SliceExpr provide expression to refer slice of Array.
-type SliceExpr struct {
-	ExprImpl
-	Value Expr
-	Begin Expr
-	End   Expr
-}
-
-// FuncExpr provide function expression.
-type FuncExpr struct {
-	ExprImpl
-	Name   string
-	Stmts  []Stmt
-	Args   []string
-	VarArg bool
-}
-
-// LetExpr provide expression to let variable.
-type LetExpr struct {
-	ExprImpl
-	Lhs Expr
-	Rhs Expr
-}
-
-// LetsExpr provide multiple expression of let.
-type LetsExpr struct {
-	ExprImpl
-	Lhss     []Expr
-	Operator string
-	Rhss     []Expr
-}
-
-// AssocExpr provide expression to assoc operation.
-type AssocExpr struct {
-	ExprImpl
-	Lhs      Expr
-	Operator string
-	Rhs      Expr
-}
-
-// NewExpr provide expression to make new instance.
-type NewExpr struct {
-	ExprImpl
-	Name     string
-	SubExprs []Expr
-}
-
-// ConstExpr provide expression for constant variable.
-type ConstExpr struct {
-	ExprImpl
-	Value string
-}
-
-type ChanExpr struct {
-	ExprImpl
-	Lhs Expr
-	Rhs Expr
-}
-
-type Type struct {
-	Name string
-}
-
-type MakeChanExpr struct {
-	ExprImpl
-	Type     string
-	SizeExpr Expr
-}
-
-type MakeArrayExpr struct {
-	ExprImpl
-	Type    string
-	LenExpr Expr
-	CapExpr Expr
-}

vendor/github.com/mattn/anko/ast/pos.go

@@ -1,28 +0,0 @@
-package ast
-
-// Position provides interface to store code locations.
-type Position struct {
-	Line   int
-	Column int
-}
-
-// Pos interface provies two functions to get/set the position for expression or statement.
-type Pos interface {
-	Position() Position
-	SetPosition(Position)
-}
-
-// PosImpl provies commonly implementations for Pos.
-type PosImpl struct {
-	pos Position
-}
-
-// Position return the position of the expression or statement.
-func (x *PosImpl) Position() Position {
-	return x.pos
-}
-
-// SetPosition is a function to specify position of the expression or statement.
-func (x *PosImpl) SetPosition(pos Position) {
-	x.pos = pos
-}

vendor/github.com/mattn/anko/ast/stmt.go

@@ -1,127 +0,0 @@
-package ast
-
-// Stmt provides all of interfaces for statement.
-type Stmt interface {
-	Pos
-	stmt()
-}
-
-// StmtImpl provide commonly implementations for Stmt..
-type StmtImpl struct {
-	PosImpl // StmtImpl provide Pos() function.
-}
-
-// stmt provide restraint interface.
-func (x *StmtImpl) stmt() {}
-
-// ExprStmt provide expression statement.
-type ExprStmt struct {
-	StmtImpl
-	Expr Expr
-}
-
-// IfStmt provide "if/else" statement.
-type IfStmt struct {
-	StmtImpl
-	If     Expr
-	Then   []Stmt
-	ElseIf []Stmt // This is array of IfStmt
-	Else   []Stmt
-}
-
-// TryStmt provide "try/catch/finally" statement.
-type TryStmt struct {
-	StmtImpl
-	Try     []Stmt
-	Var     string
-	Catch   []Stmt
-	Finally []Stmt
-}
-
-// ForStmt provide "for in" expression statement.
-type ForStmt struct {
-	StmtImpl
-	Var   string
-	Value Expr
-	Stmts []Stmt
-}
-
-// CForStmt provide C-style "for (;;)" expression statement.
-type CForStmt struct {
-	StmtImpl
-	Expr1 Expr
-	Expr2 Expr
-	Expr3 Expr
-	Stmts []Stmt
-}
-
-// LoopStmt provide "for expr" expression statement.
-type LoopStmt struct {
-	StmtImpl
-	Expr  Expr
-	Stmts []Stmt
-}
-
-// BreakStmt provide "break" expression statement.
-type BreakStmt struct {
-	StmtImpl
-}
-
-// ContinueStmt provide "continue" expression statement.
-type ContinueStmt struct {
-	StmtImpl
-}
-
-// ForStmt provide "return" expression statement.
-type ReturnStmt struct {
-	StmtImpl
-	Exprs []Expr
-}
-
-// ThrowStmt provide "throw" expression statement.
-type ThrowStmt struct {
-	StmtImpl
-	Expr Expr
-}
-
-// ModuleStmt provide "module" expression statement.
-type ModuleStmt struct {
-	StmtImpl
-	Name  string
-	Stmts []Stmt
-}
-
-// VarStmt provide statement to let variables in current scope.
-type VarStmt struct {
-	StmtImpl
-	Names []string
-	Exprs []Expr
-}
-
-// SwitchStmt provide switch statement.
-type SwitchStmt struct {
-	StmtImpl
-	Expr  Expr
-	Cases []Stmt
-}
-
-// CaseStmt provide switch/case statement.
-type CaseStmt struct {
-	StmtImpl
-	Expr  Expr
-	Stmts []Stmt
-}
-
-// DefaultStmt provide switch/default statement.
-type DefaultStmt struct {
-	StmtImpl
-	Stmts []Stmt
-}
-
-// LetsStmt provide multiple statement of let.
-type LetsStmt struct {
-	StmtImpl
-	Lhss     []Expr
-	Operator string
-	Rhss     []Expr
-}

vendor/github.com/mattn/anko/ast/token.go

@@ -1,7 +0,0 @@
-package ast
-
-type Token struct {
-	PosImpl // StmtImpl provide Pos() function.
-	Tok     int
-	Lit     string
-}

vendor/github.com/mattn/anko/parser/Makefile

@@ -1,4 +0,0 @@
-all : parser.go
-
-parser.go : parser.go.y
-	go tool yacc -o $@ parser.go.y

vendor/github.com/mattn/anko/parser/lexer.go

@@ -1,530 +0,0 @@
-// Package parser implements parser for anko.
-package parser
-
-import (
-	"errors"
-	"fmt"
-
-	"github.com/mattn/anko/ast"
-)
-
-const (
-	EOF = -1   // End of file.
-	EOL = '\n' // End of line.
-)
-
-// Error provides a convenient interface for handling runtime error.
-// It can be Error inteface with type cast which can call Pos().
-type Error struct {
-	Message  string
-	Pos      ast.Position
-	Filename string
-	Fatal    bool
-}
-
-// Error returns the error message.
-func (e *Error) Error() string {
-	return e.Message
-}
-
-// Scanner stores informations for lexer.
-type Scanner struct {
-	src      []rune
-	offset   int
-	lineHead int
-	line     int
-}
-
-// opName is correction of operation names.
-var opName = map[string]int{
-	"func":     FUNC,
-	"return":   RETURN,
-	"var":      VAR,
-	"throw":    THROW,
-	"if":       IF,
-	"for":      FOR,
-	"break":    BREAK,
-	"continue": CONTINUE,
-	"in":       IN,
-	"else":     ELSE,
-	"new":      NEW,
-	"true":     TRUE,
-	"false":    FALSE,
-	"nil":      NIL,
-	"module":   MODULE,
-	"try":      TRY,
-	"catch":    CATCH,
-	"finally":  FINALLY,
-	"switch":   SWITCH,
-	"case":     CASE,
-	"default":  DEFAULT,
-	"go":       GO,
-	"chan":     CHAN,
-	"make":     MAKE,
-}
-
-// Init resets code to scan.
-func (s *Scanner) Init(src string) {
-	s.src = []rune(src)
-}
-
-// Scan analyses token, and decide identify or literals.
-func (s *Scanner) Scan() (tok int, lit string, pos ast.Position, err error) {
-retry:
-	s.skipBlank()
-	pos = s.pos()
-	switch ch := s.peek(); {
-	case isLetter(ch):
-		lit, err = s.scanIdentifier()
-		if err != nil {
-			return
-		}
-		if name, ok := opName[lit]; ok {
-			tok = name
-		} else {
-			tok = IDENT
-		}
-	case isDigit(ch):
-		tok = NUMBER
-		lit, err = s.scanNumber()
-		if err != nil {
-			return
-		}
-	case ch == '"':
-		tok = STRING
-		lit, err = s.scanString('"')
-		if err != nil {
-			return
-		}
-	case ch == '\'':
-		tok = STRING
-		lit, err = s.scanString('\'')
-		if err != nil {
-			return
-		}
-	case ch == '`':
-		tok = STRING
-		lit, err = s.scanRawString()
-		if err != nil {
-			return
-		}
-	default:
-		switch ch {
-		case EOF:
-			tok = EOF
-		case '#':
-			for !isEOL(s.peek()) {
-				s.next()
-			}
-			goto retry
-		case '!':
-			s.next()
-			switch s.peek() {
-			case '=':
-				tok = NEQ
-				lit = "!="
-			default:
-				s.back()
-				tok = int(ch)
-				lit = string(ch)
-			}
-		case '=':
-			s.next()
-			switch s.peek() {
-			case '=':
-				tok = EQEQ
-				lit = "=="
-			default:
-				s.back()
-				tok = int(ch)
-				lit = string(ch)
-			}
-		case '+':
-			s.next()
-			switch s.peek() {
-			case '+':
-				tok = PLUSPLUS
-				lit = "++"
-			case '=':
-				tok = PLUSEQ
-				lit = "+="
-			default:
-				s.back()
-				tok = int(ch)
-				lit = string(ch)
-			}
-		case '-':
-			s.next()
-			switch s.peek() {
-			case '-':
-				tok = MINUSMINUS
-				lit = "--"
-			case '=':
-				tok = MINUSEQ
-				lit = "-="
-			default:
-				s.back()
-				tok = int(ch)
-				lit = string(ch)
-			}
-		case '*':
-			s.next()
-			switch s.peek() {
-			case '*':
-				tok = POW
-				lit = "**"
-			case '=':
-				tok = MULEQ
-				lit = "*="
-			default:
-				s.back()
-				tok = int(ch)
-				lit = string(ch)
-			}
-		case '/':
-			s.next()
-			switch s.peek() {
-			case '=':
-				tok = DIVEQ
-				lit = "/="
-			default:
-				s.back()
-				tok = int(ch)
-				lit = string(ch)
-			}
-		case '>':
-			s.next()
-			switch s.peek() {
-			case '=':
-				tok = GE
-				lit = ">="
-			case '>':
-				tok = SHIFTRIGHT
-				lit = ">>"
-			default:
-				s.back()
-				tok = int(ch)
-				lit = string(ch)
-			}
-		case '<':
-			s.next()
-			switch s.peek() {
-			case '-':
-				tok = OPCHAN
-				lit = "<-"
-			case '=':
-				tok = LE
-				lit = "<="
-			case '<':
-				tok = SHIFTLEFT
-				lit = "<<"
-			default:
-				s.back()
-				tok = int(ch)
-				lit = string(ch)
-			}
-		case '|':
-			s.next()
-			switch s.peek() {
-			case '|':
-				tok = OROR
-				lit = "||"
-			case '=':
-				tok = OREQ
-				lit = "|="
-			default:
-				s.back()
-				tok = int(ch)
-				lit = string(ch)
-			}
-		case '&':
-			s.next()
-			switch s.peek() {
-			case '&':
-				tok = ANDAND
-				lit = "&&"
-			case '=':
-				tok = ANDEQ
-				lit = "&="
-			default:
-				s.back()
-				tok = int(ch)
-				lit = string(ch)
-			}
-		case '.':
-			s.next()
-			if s.peek() == '.' {
-				s.next()
-				if s.peek() == '.' {
-					tok = VARARG
-				} else {
-					err = fmt.Errorf(`syntax error "%s"`, "..")
-					return
-				}
-			} else {
-				s.back()
-				tok = int(ch)
-				lit = string(ch)
-			}
-		case '(', ')', ':', ';', '%', '?', '{', '}', ',', '[', ']', '^', '\n':
-			s.next()
-			if ch == '[' && s.peek() == ']' {
-				s.next()
-				if isLetter(s.peek()) {
-					s.back()
-					tok = ARRAYLIT
-					lit = "[]"
-				} else {
-					s.back()
-					s.back()
-					tok = int(ch)
-					lit = string(ch)
-				}
-			} else {
-				s.back()
-				tok = int(ch)
-				lit = string(ch)
-			}
-		default:
-			err = fmt.Errorf(`syntax error "%s"`, string(ch))
-			return
-		}
-		s.next()
-	}
-	return
-}
-
-// isLetter returns true if the rune is a letter for identity.
-func isLetter(ch rune) bool {
-	return 'a' <= ch && ch <= 'z' || 'A' <= ch && ch <= 'Z' || ch == '_'
-}
-
-// isDigit returns true if the rune is a number.
-func isDigit(ch rune) bool {
-	return '0' <= ch && ch <= '9'
-}
-
-// isHex returns true if the rune is a hex digits.
-func isHex(ch rune) bool {
-	return ('0' <= ch && ch <= '9') || ('a' <= ch && ch <= 'f') || ('A' <= ch && ch <= 'F')
-}
-
-// isEOL returns true if the rune is at end-of-line or end-of-file.
-func isEOL(ch rune) bool {
-	return ch == '\n' || ch == -1
-}
-
-// isBlank returns true if the rune is empty character..
-func isBlank(ch rune) bool {
-	return ch == ' ' || ch == '\t' || ch == '\r'
-}
-
-// peek returns current rune in the code.
-func (s *Scanner) peek() rune {
-	if s.reachEOF() {
-		return EOF
-	}
-	return s.src[s.offset]
-}
-
-// next moves offset to next.
-func (s *Scanner) next() {
-	if !s.reachEOF() {
-		if s.peek() == '\n' {
-			s.lineHead = s.offset + 1
-			s.line++
-		}
-		s.offset++
-	}
-}
-
-// current returns the current offset.
-func (s *Scanner) current() int {
-	return s.offset
-}
-
-// offset sets the offset value.
-func (s *Scanner) set(o int) {
-	s.offset = o
-}
-
-// back moves back offset once to top.
-func (s *Scanner) back() {
-	s.offset--
-}
-
-// reachEOF returns true if offset is at end-of-file.
-func (s *Scanner) reachEOF() bool {
-	return len(s.src) <= s.offset
-}
-
-// pos returns the position of current.
-func (s *Scanner) pos() ast.Position {
-	return ast.Position{Line: s.line + 1, Column: s.offset - s.lineHead + 1}
-}
-
-// skipBlank moves position into non-black character.
-func (s *Scanner) skipBlank() {
-	for isBlank(s.peek()) {
-		s.next()
-	}
-}
-
-// scanIdentifier returns identifier begining at current position.
-func (s *Scanner) scanIdentifier() (string, error) {
-	var ret []rune
-	for {
-		if !isLetter(s.peek()) && !isDigit(s.peek()) {
-			break
-		}
-		ret = append(ret, s.peek())
-		s.next()
-	}
-	return string(ret), nil
-}
-
-// scanNumber returns number begining at current position.
-func (s *Scanner) scanNumber() (string, error) {
-	var ret []rune
-	ch := s.peek()
-	ret = append(ret, ch)
-	s.next()
-	if ch == '0' && s.peek() == 'x' {
-		ret = append(ret, s.peek())
-		s.next()
-		for isHex(s.peek()) {
-			ret = append(ret, s.peek())
-			s.next()
-		}
-	} else {
-		for isDigit(s.peek()) || s.peek() == '.' {
-			ret = append(ret, s.peek())
-			s.next()
-		}
-		if s.peek() == 'e' {
-			ret = append(ret, s.peek())
-			s.next()
-			if isDigit(s.peek()) || s.peek() == '+' || s.peek() == '-' {
-				ret = append(ret, s.peek())
-				s.next()
-				for isDigit(s.peek()) || s.peek() == '.' {
-					ret = append(ret, s.peek())
-					s.next()
-				}
-			}
-			for isDigit(s.peek()) || s.peek() == '.' {
-				ret = append(ret, s.peek())
-				s.next()
-			}
-		}
-		if isLetter(s.peek()) {
-			return "", errors.New("identifier starts immediately after numeric literal")
-		}
-	}
-	return string(ret), nil
-}
-
-// scanRawString returns raw-string starting at current position.
-func (s *Scanner) scanRawString() (string, error) {
-	var ret []rune
-	for {
-		s.next()
-		if s.peek() == EOF {
-			return "", errors.New("unexpected EOF")
-			break
-		}
-		if s.peek() == '`' {
-			s.next()
-			break
-		}
-		ret = append(ret, s.peek())
-	}
-	return string(ret), nil
-}
-
-// scanString returns string starting at current position.
-// This handles backslash escaping.
-func (s *Scanner) scanString(l rune) (string, error) {
-	var ret []rune
-eos:
-	for {
-		s.next()
-		switch s.peek() {
-		case EOL:
-			return "", errors.New("unexpected EOL")
-		case EOF:
-			return "", errors.New("unexpected EOF")
-		case l:
-			s.next()
-			break eos
-		case '\\':
-			s.next()
-			switch s.peek() {
-			case 'b':
-				ret = append(ret, '\b')
-				continue
-			case 'f':
-				ret = append(ret, '\f')
-				continue
-			case 'r':
-				ret = append(ret, '\r')
-				continue
-			case 'n':
-				ret = append(ret, '\n')
-				continue
-			case 't':
-				ret = append(ret, '\t')
-				continue
-			}
-			ret = append(ret, s.peek())
-			continue
-		default:
-			ret = append(ret, s.peek())
-		}
-	}
-	return string(ret), nil
-}
-
-// Lexer provides inteface to parse codes.
-type Lexer struct {
-	s     *Scanner
-	lit   string
-	pos   ast.Position
-	e     error
-	stmts []ast.Stmt
-}
-
-// Lex scans the token and literals.
-func (l *Lexer) Lex(lval *yySymType) int {
-	tok, lit, pos, err := l.s.Scan()
-	if err != nil {
-		l.e = &Error{Message: fmt.Sprintf("%s", err.Error()), Pos: pos, Fatal: true}
-	}
-	lval.tok = ast.Token{Tok: tok, Lit: lit}
-	lval.tok.SetPosition(pos)
-	l.lit = lit
-	l.pos = pos
-	return tok
-}
-
-// Error sets parse error.
-func (l *Lexer) Error(msg string) {
-	l.e = &Error{Message: msg, Pos: l.pos, Fatal: false}
-}
-
-// Parser provides way to parse the code using Scanner.
-func Parse(s *Scanner) ([]ast.Stmt, error) {
-	l := Lexer{s: s}
-	if yyParse(&l) != 0 {
-		return nil, l.e
-	}
-	return l.stmts, l.e
-}
-
-// ParserSrc provides way to parse the code from source.
-func ParseSrc(src string) ([]ast.Stmt, error) {
-	scanner := &Scanner{
-		src: []rune(src),
-	}
-	return Parse(scanner)
-}

vendor/github.com/mattn/anko/parser/parser.go.y

@@ -1,705 +0,0 @@
-%{
-package parser
-
-import (
-	"github.com/mattn/anko/ast"
-)
-
-%}
-
-%type<compstmt> compstmt
-%type<stmts> stmts
-%type<stmt> stmt
-%type<stmt_if> stmt_if
-%type<stmt_default> stmt_default
-%type<stmt_case> stmt_case
-%type<stmt_cases> stmt_cases
-%type<typ> typ
-%type<expr> expr
-%type<exprs> exprs
-%type<expr_many> expr_many
-%type<expr_lets> expr_lets
-%type<expr_pair> expr_pair
-%type<expr_pairs> expr_pairs
-%type<expr_idents> expr_idents
-
-%union{
-	compstmt               []ast.Stmt
-	stmt_if                ast.Stmt
-	stmt_default           ast.Stmt
-	stmt_case              ast.Stmt
-	stmt_cases             []ast.Stmt
-	stmts                  []ast.Stmt
-	stmt                   ast.Stmt
-	typ                    ast.Type
-	expr                   ast.Expr
-	exprs                  []ast.Expr
-	expr_many              []ast.Expr
-	expr_lets              ast.Expr
-	expr_pair              ast.Expr
-	expr_pairs             []ast.Expr
-	expr_idents            []string
-	tok                    ast.Token
-	term                   ast.Token
-	terms                  ast.Token
-	opt_terms              ast.Token
-}
-
-%token<tok> IDENT NUMBER STRING ARRAY VARARG FUNC RETURN VAR THROW IF ELSE FOR IN EQEQ NEQ GE LE OROR ANDAND NEW TRUE FALSE NIL MODULE TRY CATCH FINALLY PLUSEQ MINUSEQ MULEQ DIVEQ ANDEQ OREQ BREAK CONTINUE PLUSPLUS MINUSMINUS POW SHIFTLEFT SHIFTRIGHT SWITCH CASE DEFAULT GO CHAN MAKE OPCHAN ARRAYLIT
-
-%right '='
-%right '?' ':'
-%left OROR
-%left ANDAND
-%left IDENT
-%nonassoc EQEQ NEQ ','
-%left '>' GE '<' LE SHIFTLEFT SHIFTRIGHT
-
-%left '+' '-' PLUSPLUS MINUSMINUS
-%left '*' '/' '%'
-%right UNARY
-
-%%
-
-compstmt : opt_terms
-	{
-		$$ = nil
-	}
-	| stmts opt_terms
-	{
-		$$ = $1
-	}
-
-stmts :
-	{
-		$$ = nil
-		if l, ok := yylex.(*Lexer); ok {
-			l.stmts = $$
-		}
-	}
-	| opt_terms stmt
-	{
-		$$ = []ast.Stmt{$2}
-		if l, ok := yylex.(*Lexer); ok {
-			l.stmts = $$
-		}
-	}
-	| stmts terms stmt
-	{
-		if $3 != nil {
-			$$ = append($1, $3)
-			if l, ok := yylex.(*Lexer); ok {
-				l.stmts = $$
-			}
-		}
-	}
-
-stmt :
-	VAR expr_idents '=' expr_many
-	{
-		$$ = &ast.VarStmt{Names: $2, Exprs: $4}
-		$$.SetPosition($1.Position())
-	}
-	| expr '=' expr
-	{
-		$$ = &ast.LetsStmt{Lhss: []ast.Expr{$1}, Operator: "=", Rhss: []ast.Expr{$3}}
-	}
-	| expr_many '=' expr_many
-	{
-		$$ = &ast.LetsStmt{Lhss: $1, Operator: "=", Rhss: $3}
-	}
-	| BREAK
-	{
-		$$ = &ast.BreakStmt{}
-		$$.SetPosition($1.Position())
-	}
-	| CONTINUE
-	{
-		$$ = &ast.ContinueStmt{}
-		$$.SetPosition($1.Position())
-	}
-	| RETURN exprs
-	{
-		$$ = &ast.ReturnStmt{Exprs: $2}
-		$$.SetPosition($1.Position())
-	}
-	| THROW expr
-	{
-		$$ = &ast.ThrowStmt{Expr: $2}
-		$$.SetPosition($1.Position())
-	}
-	| MODULE IDENT '{' compstmt '}'
-	{
-		$$ = &ast.ModuleStmt{Name: $2.Lit, Stmts: $4}
-		$$.SetPosition($1.Position())
-	}
-	| stmt_if
-	{
-		$$ = $1
-		$$.SetPosition($1.Position())
-	}
-	| FOR '{' compstmt '}'
-	{
-		$$ = &ast.LoopStmt{Stmts: $3}
-		$$.SetPosition($1.Position())
-	}
-	| FOR IDENT IN expr '{' compstmt '}'
-	{
-		$$ = &ast.ForStmt{Var: $2.Lit, Value: $4, Stmts: $6}
-		$$.SetPosition($1.Position())
-	}
-	| FOR expr_lets ';' expr ';' expr '{' compstmt '}'
-	{
-		$$ = &ast.CForStmt{Expr1: $2, Expr2: $4, Expr3: $6, Stmts: $8}
-		$$.SetPosition($1.Position())
-	}
-	| FOR expr '{' compstmt '}'
-	{
-		$$ = &ast.LoopStmt{Expr: $2, Stmts: $4}
-		$$.SetPosition($1.Position())
-	}
-	| TRY '{' compstmt '}' CATCH IDENT '{' compstmt '}' FINALLY '{' compstmt '}'
-	{
-		$$ = &ast.TryStmt{Try: $3, Var: $6.Lit, Catch: $8, Finally: $12}
-		$$.SetPosition($1.Position())
-	}
-	| TRY '{' compstmt '}' CATCH '{' compstmt '}' FINALLY '{' compstmt '}'
-	{
-		$$ = &ast.TryStmt{Try: $3, Catch: $7, Finally: $11}
-		$$.SetPosition($1.Position())
-	}
-	| TRY '{' compstmt '}' CATCH IDENT '{' compstmt '}'
-	{
-		$$ = &ast.TryStmt{Try: $3, Var: $6.Lit, Catch: $8}
-		$$.SetPosition($1.Position())
-	}
-	| TRY '{' compstmt '}' CATCH '{' compstmt '}'
-	{
-		$$ = &ast.TryStmt{Try: $3, Catch: $7}
-		$$.SetPosition($1.Position())
-	}
-	| SWITCH expr '{' stmt_cases '}'
-	{
-		$$ = &ast.SwitchStmt{Expr: $2, Cases: $4}
-		$$.SetPosition($1.Position())
-	}
-	| expr
-	{
-		$$ = &ast.ExprStmt{Expr: $1}
-		$$.SetPosition($1.Position())
-	}
-
-
-stmt_if :
-	stmt_if ELSE IF expr '{' compstmt '}'
-	{
-		$1.(*ast.IfStmt).ElseIf = append($1.(*ast.IfStmt).ElseIf, &ast.IfStmt{If: $4, Then: $6})
-		$$.SetPosition($1.Position())
-	}
-	| stmt_if ELSE '{' compstmt '}'
-	{
-		if $$.(*ast.IfStmt).Else != nil {
-			yylex.Error("multiple else statement")
-		} else {
-			$$.(*ast.IfStmt).Else = append($$.(*ast.IfStmt).Else, $4...)
-		}
-		$$.SetPosition($1.Position())
-	}
-	| IF expr '{' compstmt '}'
-	{
-		$$ = &ast.IfStmt{If: $2, Then: $4, Else: nil}
-		$$.SetPosition($1.Position())
-	}
-
-stmt_cases :
-	{
-		$$ = []ast.Stmt{}
-	}
-	| opt_terms stmt_case
-	{
-		$$ = []ast.Stmt{$2}
-	}
-	| opt_terms stmt_default
-	{
-		$$ = []ast.Stmt{$2}
-	}
-	| stmt_cases stmt_case
-	{
-		$$ = append($1, $2)
-	}
-	| stmt_cases stmt_default
-	{
-		for _, stmt := range $1 {
-			if _, ok := stmt.(*ast.DefaultStmt); ok {
-				yylex.Error("multiple default statement")
-			}
-		}
-		$$ = append($1, $2)
-	}
-
-stmt_case :
-	CASE expr ':' opt_terms compstmt
-	{
-		$$ = &ast.CaseStmt{Expr: $2, Stmts: $5}
-	}
-
-stmt_default :
-	DEFAULT ':' opt_terms compstmt
-	{
-		$$ = &ast.DefaultStmt{Stmts: $4}
-	}
-
-expr_pair :
-	STRING ':' expr
-	{
-		$$ = &ast.PairExpr{Key: $1.Lit, Value: $3}
-	}
-
-expr_pairs :
-	{
-		$$ = []ast.Expr{}
-	}
-	| expr_pair
-	{
-		$$ = []ast.Expr{$1}
-	}
-	| expr_pairs ',' opt_terms expr_pair
-	{
-		$$ = append($1, $4)
-	}
-
-expr_idents :
-	{
-		$$ = []string{}
-	}
-	| IDENT
-	{
-		$$ = []string{$1.Lit}
-	}
-	| expr_idents ',' opt_terms IDENT
-	{
-		$$ = append($1, $4.Lit)
-	}
-
-expr_lets : expr_many '=' expr_many
-	{
-		$$ = &ast.LetsExpr{Lhss: $1, Operator: "=", Rhss: $3}
-	}
-
-expr_many :
-	expr
-	{
-		$$ = []ast.Expr{$1}
-	}
-	| exprs ',' opt_terms expr
-	{
-		$$ = append($1, $4)
-	}
-	| exprs ',' opt_terms IDENT
-	{
-		$$ = append($1, &ast.IdentExpr{Lit: $4.Lit})
-	}
-
-typ : IDENT
-	{
-		$$ = ast.Type{Name: $1.Lit}
-	}
-	| typ '.' IDENT
-	{
-		$$ = ast.Type{Name: $1.Name + "." + $3.Lit}
-	}
-
-exprs :
-	{
-		$$ = nil
-	}
-	| expr 
-	{
-		$$ = []ast.Expr{$1}
-	}
-	| exprs ',' opt_terms expr
-	{
-		$$ = append($1, $4)
-	}
-	| exprs ',' opt_terms IDENT
-	{
-		$$ = append($1, &ast.IdentExpr{Lit: $4.Lit})
-	}
-
-expr :
-	IDENT
-	{
-		$$ = &ast.IdentExpr{Lit: $1.Lit}
-		$$.SetPosition($1.Position())
-	}
-	| NUMBER
-	{
-		$$ = &ast.NumberExpr{Lit: $1.Lit}
-		$$.SetPosition($1.Position())
-	}
-	| '-' expr %prec UNARY
-	{
-		$$ = &ast.UnaryExpr{Operator: "-", Expr: $2}
-		$$.SetPosition($2.Position())
-	}
-	| '!' expr %prec UNARY
-	{
-		$$ = &ast.UnaryExpr{Operator: "!", Expr: $2}
-		$$.SetPosition($2.Position())
-	}
-	| '^' expr %prec UNARY
-	{
-		$$ = &ast.UnaryExpr{Operator: "^", Expr: $2}
-		$$.SetPosition($2.Position())
-	}
-	| '&' IDENT %prec UNARY
-	{
-		$$ = &ast.AddrExpr{Expr: &ast.IdentExpr{Lit: $2.Lit}}
-		$$.SetPosition($2.Position())
-	}
-	| '&' expr '.' IDENT %prec UNARY
-	{
-		$$ = &ast.AddrExpr{Expr: &ast.MemberExpr{Expr: $2, Name: $4.Lit}}
-		$$.SetPosition($2.Position())
-	}
-	| '*' IDENT %prec UNARY
-	{
-		$$ = &ast.DerefExpr{Expr: &ast.IdentExpr{Lit: $2.Lit}}
-		$$.SetPosition($2.Position())
-	}
-	| '*' expr '.' IDENT %prec UNARY
-	{
-		$$ = &ast.DerefExpr{Expr: &ast.MemberExpr{Expr: $2, Name: $4.Lit}}
-		$$.SetPosition($2.Position())
-	}
-	| STRING
-	{
-		$$ = &ast.StringExpr{Lit: $1.Lit}
-		$$.SetPosition($1.Position())
-	}
-	| TRUE
-	{
-		$$ = &ast.ConstExpr{Value: $1.Lit}
-		$$.SetPosition($1.Position())
-	}
-	| FALSE
-	{
-		$$ = &ast.ConstExpr{Value: $1.Lit}
-		$$.SetPosition($1.Position())
-	}
-	| NIL
-	{
-		$$ = &ast.ConstExpr{Value: $1.Lit}
-		$$.SetPosition($1.Position())
-	}
-	| expr '?' expr ':' expr
-	{
-		$$ = &ast.TernaryOpExpr{Expr: $1, Lhs: $3, Rhs: $5}
-		$$.SetPosition($1.Position())
-	}
-	| expr '.' IDENT
-	{
-		$$ = &ast.MemberExpr{Expr: $1, Name: $3.Lit}
-		$$.SetPosition($1.Position())
-	}
-	| FUNC '(' expr_idents ')' '{' compstmt '}'
-	{
-		$$ = &ast.FuncExpr{Args: $3, Stmts: $6}
-		$$.SetPosition($1.Position())
-	}
-	| FUNC '(' IDENT VARARG ')' '{' compstmt '}'
-	{
-		$$ = &ast.FuncExpr{Args: []string{$3.Lit}, Stmts: $7, VarArg: true}
-		$$.SetPosition($1.Position())
-	}
-	| FUNC IDENT '(' expr_idents ')' '{' compstmt '}'
-	{
-		$$ = &ast.FuncExpr{Name: $2.Lit, Args: $4, Stmts: $7}
-		$$.SetPosition($1.Position())
-	}
-	| FUNC IDENT '(' IDENT VARARG ')' '{' compstmt '}'
-	{
-		$$ = &ast.FuncExpr{Name: $2.Lit, Args: []string{$4.Lit}, Stmts: $8, VarArg: true}
-		$$.SetPosition($1.Position())
-	}
-	| '[' opt_terms exprs opt_terms ']'
-	{
-		$$ = &ast.ArrayExpr{Exprs: $3}
-		if l, ok := yylex.(*Lexer); ok { $$.SetPosition(l.pos) }
-	}
-	| '[' opt_terms exprs ',' opt_terms ']'
-	{
-		$$ = &ast.ArrayExpr{Exprs: $3}
-		if l, ok := yylex.(*Lexer); ok { $$.SetPosition(l.pos) }
-	}
-	| '{' opt_terms expr_pairs opt_terms '}'
-	{
-		mapExpr := make(map[string]ast.Expr)
-		for _, v := range $3 {
-			mapExpr[v.(*ast.PairExpr).Key] = v.(*ast.PairExpr).Value
-		}
-		$$ = &ast.MapExpr{MapExpr: mapExpr}
-		if l, ok := yylex.(*Lexer); ok { $$.SetPosition(l.pos) }
-	}
-	| '{' opt_terms expr_pairs ',' opt_terms '}'
-	{
-		mapExpr := make(map[string]ast.Expr)
-		for _, v := range $3 {
-			mapExpr[v.(*ast.PairExpr).Key] = v.(*ast.PairExpr).Value
-		}
-		$$ = &ast.MapExpr{MapExpr: mapExpr}
-		if l, ok := yylex.(*Lexer); ok { $$.SetPosition(l.pos) }
-	}
-	| '(' expr ')'
-	{
-		$$ = &ast.ParenExpr{SubExpr: $2}
-		if l, ok := yylex.(*Lexer); ok { $$.SetPosition(l.pos) }
-	}
-	| NEW IDENT '(' exprs ')'
-	{
-		$$ = &ast.NewExpr{Name: $2.Lit, SubExprs: $4}
-		$$.SetPosition($1.Position())
-	}
-	| expr '+' expr
-	{
-		$$ = &ast.BinOpExpr{Lhs: $1, Operator: "+", Rhs: $3}
-		$$.SetPosition($1.Position())
-	}
-	| expr '-' expr
-	{
-		$$ = &ast.BinOpExpr{Lhs: $1, Operator: "-", Rhs: $3}
-		$$.SetPosition($1.Position())
-	}
-	| expr '*' expr
-	{
-		$$ = &ast.BinOpExpr{Lhs: $1, Operator: "*", Rhs: $3}
-		$$.SetPosition($1.Position())
-	}
-	| expr '/' expr
-	{
-		$$ = &ast.BinOpExpr{Lhs: $1, Operator: "/", Rhs: $3}
-		$$.SetPosition($1.Position())
-	}
-	| expr '%' expr
-	{
-		$$ = &ast.BinOpExpr{Lhs: $1, Operator: "%", Rhs: $3}
-		$$.SetPosition($1.Position())
-	}
-	| expr POW expr
-	{
-		$$ = &ast.BinOpExpr{Lhs: $1, Operator: "**", Rhs: $3}
-		$$.SetPosition($1.Position())
-	}
-	| expr SHIFTLEFT expr
-	{
-		$$ = &ast.BinOpExpr{Lhs: $1, Operator: "<<", Rhs: $3}
-		$$.SetPosition($1.Position())
-	}
-	| expr SHIFTRIGHT expr
-	{
-		$$ = &ast.BinOpExpr{Lhs: $1, Operator: ">>", Rhs: $3}
-		$$.SetPosition($1.Position())
-	}
-	| expr EQEQ expr
-	{
-		$$ = &ast.BinOpExpr{Lhs: $1, Operator: "==", Rhs: $3}
-		$$.SetPosition($1.Position())
-	}
-	| expr NEQ expr
-	{
-		$$ = &ast.BinOpExpr{Lhs: $1, Operator: "!=", Rhs: $3}
-		$$.SetPosition($1.Position())
-	}
-	| expr '>' expr
-	{
-		$$ = &ast.BinOpExpr{Lhs: $1, Operator: ">", Rhs: $3}
-		$$.SetPosition($1.Position())
-	}
-	| expr GE expr
-	{
-		$$ = &ast.BinOpExpr{Lhs: $1, Operator: ">=", Rhs: $3}
-		$$.SetPosition($1.Position())
-	}
-	| expr '<' expr
-	{
-		$$ = &ast.BinOpExpr{Lhs: $1, Operator: "<", Rhs: $3}
-		$$.SetPosition($1.Position())
-	}
-	| expr LE expr
-	{
-		$$ = &ast.BinOpExpr{Lhs: $1, Operator: "<=", Rhs: $3}
-		$$.SetPosition($1.Position())
-	}
-	| expr PLUSEQ expr
-	{
-		$$ = &ast.AssocExpr{Lhs: $1, Operator: "+=", Rhs: $3}
-		$$.SetPosition($1.Position())
-	}
-	| expr MINUSEQ expr
-	{
-		$$ = &ast.AssocExpr{Lhs: $1, Operator: "-=", Rhs: $3}
-		$$.SetPosition($1.Position())
-	}
-	| expr MULEQ expr
-	{
-		$$ = &ast.AssocExpr{Lhs: $1, Operator: "*=", Rhs: $3}
-		$$.SetPosition($1.Position())
-	}
-	| expr DIVEQ expr
-	{
-		$$ = &ast.AssocExpr{Lhs: $1, Operator: "/=", Rhs: $3}
-		$$.SetPosition($1.Position())
-	}
-	| expr ANDEQ expr
-	{
-		$$ = &ast.AssocExpr{Lhs: $1, Operator: "&=", Rhs: $3}
-		$$.SetPosition($1.Position())
-	}
-	| expr OREQ expr
-	{
-		$$ = &ast.AssocExpr{Lhs: $1, Operator: "|=", Rhs: $3}
-		$$.SetPosition($1.Position())
-	}
-	| expr PLUSPLUS
-	{
-		$$ = &ast.AssocExpr{Lhs: $1, Operator: "++"}
-		$$.SetPosition($1.Position())
-	}
-	| expr MINUSMINUS
-	{
-		$$ = &ast.AssocExpr{Lhs: $1, Operator: "--"}
-		$$.SetPosition($1.Position())
-	}
-	| expr '|' expr
-	{
-		$$ = &ast.BinOpExpr{Lhs: $1, Operator: "|", Rhs: $3}
-		$$.SetPosition($1.Position())
-	}
-	| expr OROR expr
-	{
-		$$ = &ast.BinOpExpr{Lhs: $1, Operator: "||", Rhs: $3}
-		$$.SetPosition($1.Position())
-	}
-	| expr '&' expr
-	{
-		$$ = &ast.BinOpExpr{Lhs: $1, Operator: "&", Rhs: $3}
-		$$.SetPosition($1.Position())
-	}
-	| expr ANDAND expr
-	{
-		$$ = &ast.BinOpExpr{Lhs: $1, Operator: "&&", Rhs: $3}
-		$$.SetPosition($1.Position())
-	}
-	| IDENT '(' exprs VARARG ')'
-	{
-		$$ = &ast.CallExpr{Name: $1.Lit, SubExprs: $3, VarArg: true}
-		$$.SetPosition($1.Position())
-	}
-	| IDENT '(' exprs ')'
-	{
-		$$ = &ast.CallExpr{Name: $1.Lit, SubExprs: $3}
-		$$.SetPosition($1.Position())
-	}
-	| GO IDENT '(' exprs VARARG ')'
-	{
-		$$ = &ast.CallExpr{Name: $2.Lit, SubExprs: $4, VarArg: true, Go: true}
-		$$.SetPosition($2.Position())
-	}
-	| GO IDENT '(' exprs ')'
-	{
-		$$ = &ast.CallExpr{Name: $2.Lit, SubExprs: $4, Go: true}
-		$$.SetPosition($2.Position())
-	}
-	| expr '(' exprs VARARG ')'
-	{
-		$$ = &ast.AnonCallExpr{Expr: $1, SubExprs: $3, VarArg: true}
-		$$.SetPosition($1.Position())
-	}
-	| expr '(' exprs ')'
-	{
-		$$ = &ast.AnonCallExpr{Expr: $1, SubExprs: $3}
-		$$.SetPosition($1.Position())
-	}
-	| GO expr '(' exprs VARARG ')'
-	{
-		$$ = &ast.AnonCallExpr{Expr: $2, SubExprs: $4, VarArg: true, Go: true}
-		$$.SetPosition($2.Position())
-	}
-	| GO expr '(' exprs ')'
-	{
-		$$ = &ast.AnonCallExpr{Expr: $2, SubExprs: $4, Go: true}
-		$$.SetPosition($1.Position())
-	}
-	| IDENT '[' expr ']'
-	{
-		$$ = &ast.ItemExpr{Value: &ast.IdentExpr{Lit: $1.Lit}, Index: $3}
-		$$.SetPosition($1.Position())
-	}
-	| expr '[' expr ']'
-	{
-		$$ = &ast.ItemExpr{Value: $1, Index: $3}
-		$$.SetPosition($1.Position())
-	}
-	| IDENT '[' expr ':' expr ']'
-	{
-		$$ = &ast.SliceExpr{Value: &ast.IdentExpr{Lit: $1.Lit}, Begin: $3, End: $5}
-		$$.SetPosition($1.Position())
-	}
-	| expr '[' expr ':' expr ']'
-	{
-		$$ = &ast.SliceExpr{Value: $1, Begin: $3, End: $5}
-		$$.SetPosition($1.Position())
-	}
-	| MAKE '(' CHAN typ ')'
-	{
-		$$ = &ast.MakeChanExpr{Type: $4.Name, SizeExpr: nil}
-		$$.SetPosition($1.Position())
-	}
-	| MAKE '(' CHAN typ ',' expr ')'
-	{
-		$$ = &ast.MakeChanExpr{Type: $4.Name, SizeExpr: $6}
-		$$.SetPosition($1.Position())
-	}
-	| MAKE '(' ARRAYLIT typ ',' expr ')'
-	{
-		$$ = &ast.MakeArrayExpr{Type: $4.Name, LenExpr: $6}
-		$$.SetPosition($1.Position())
-	}
-	| MAKE '(' ARRAYLIT typ ',' expr ',' expr ')'
-	{
-		$$ = &ast.MakeArrayExpr{Type: $4.Name, LenExpr: $6, CapExpr: $8}
-		$$.SetPosition($1.Position())
-	}
-	| expr OPCHAN expr
-	{
-		$$ = &ast.ChanExpr{Lhs: $1, Rhs: $3}
-		$$.SetPosition($1.Position())
-	}
-	| OPCHAN expr
-	{
-		$$ = &ast.ChanExpr{Rhs: $2}
-		$$.SetPosition($2.Position())
-	}
-
-opt_terms : /* none */
-	| terms
-	;
-
-
-terms : term
-	{
-	}
-	| terms term
-	{
-	}
-	;
-
-term : ';'
-	{
-	}
-	| '\n'
-	{
-	}
-	;
-
-%%

vendor/github.com/mattn/anko/vm/doc.go

@@ -1,2 +0,0 @@
-// Package vm implements virtual-machine for anko.
-package vm

vendor/github.com/mattn/anko/vm/env.go

@@ -1,258 +0,0 @@
-package vm
-
-import (
-	"fmt"
-	"reflect"
-	"strings"
-	"sync"
-
-	"github.com/mattn/anko/parser"
-)
-
-// Env provides interface to run VM. This mean function scope and blocked-scope.
-// If stack goes to blocked-scope, it will make new Env.
-type Env struct {
-	name      string
-	env       map[string]reflect.Value
-	typ       map[string]reflect.Type
-	parent    *Env
-	interrupt *bool
-	sync.RWMutex
-}
-
-// NewEnv creates new global scope.
-func NewEnv() *Env {
-	b := false
-
-	return &Env{
-		env:       make(map[string]reflect.Value),
-		typ:       make(map[string]reflect.Type),
-		parent:    nil,
-		interrupt: &b,
-	}
-}
-
-// NewEnv creates new child scope.
-func (e *Env) NewEnv() *Env {
-	return &Env{
-		env:       make(map[string]reflect.Value),
-		typ:       make(map[string]reflect.Type),
-		parent:    e,
-		name:      e.name,
-		interrupt: e.interrupt,
-	}
-}
-
-func NewPackage(n string) *Env {
-	b := false
-
-	return &Env{
-		env:       make(map[string]reflect.Value),
-		typ:       make(map[string]reflect.Type),
-		parent:    nil,
-		name:      n,
-		interrupt: &b,
-	}
-}
-
-func (e *Env) NewPackage(n string) *Env {
-	return &Env{
-		env:       make(map[string]reflect.Value),
-		typ:       make(map[string]reflect.Type),
-		parent:    e,
-		name:      n,
-		interrupt: e.interrupt,
-	}
-}
-
-// Destroy deletes current scope.
-func (e *Env) Destroy() {
-	e.Lock()
-	defer e.Unlock()
-
-	if e.parent == nil {
-		return
-	}
-	for k, v := range e.parent.env {
-		if v.IsValid() && v.Interface() == e {
-			delete(e.parent.env, k)
-		}
-	}
-	e.parent = nil
-	e.env = nil
-}
-
-// NewModule creates new module scope as global.
-func (e *Env) NewModule(n string) *Env {
-	m := &Env{
-		env:    make(map[string]reflect.Value),
-		parent: e,
-		name:   n,
-	}
-	e.Define(n, m)
-	return m
-}
-
-// SetName sets a name of the scope. This means that the scope is module.
-func (e *Env) SetName(n string) {
-	e.Lock()
-	e.name = n
-	e.Unlock()
-}
-
-// GetName returns module name.
-func (e *Env) GetName() string {
-	e.RLock()
-	defer e.RUnlock()
-
-	return e.name
-}
-
-// Addr returns pointer value which specified symbol. It goes to upper scope until
-// found or returns error.
-func (e *Env) Addr(k string) (reflect.Value, error) {
-	e.RLock()
-	defer e.RUnlock()
-
-	if v, ok := e.env[k]; ok {
-		return v.Addr(), nil
-	}
-	if e.parent == nil {
-		return NilValue, fmt.Errorf("Undefined symbol '%s'", k)
-	}
-	return e.parent.Addr(k)
-}
-
-// Type returns type which specified symbol. It goes to upper scope until
-// found or returns error.
-func (e *Env) Type(k string) (reflect.Type, error) {
-	e.RLock()
-	defer e.RUnlock()
-
-	if v, ok := e.typ[k]; ok {
-		return v, nil
-	}
-	if e.parent == nil {
-		return NilType, fmt.Errorf("Undefined type '%s'", k)
-	}
-	return e.parent.Type(k)
-}
-
-// Get returns value which specified symbol. It goes to upper scope until
-// found or returns error.
-func (e *Env) Get(k string) (reflect.Value, error) {
-	e.RLock()
-	defer e.RUnlock()
-
-	if v, ok := e.env[k]; ok {
-		return v, nil
-	}
-	if e.parent == nil {
-		return NilValue, fmt.Errorf("Undefined symbol '%s'", k)
-	}
-	return e.parent.Get(k)
-}
-
-// Set modifies value which specified as symbol. It goes to upper scope until
-// found or returns error.
-func (e *Env) Set(k string, v interface{}) error {
-	e.Lock()
-	defer e.Unlock()
-
-	if _, ok := e.env[k]; ok {
-		val, ok := v.(reflect.Value)
-		if !ok {
-			val = reflect.ValueOf(v)
-		}
-		e.env[k] = val
-		return nil
-	}
-	if e.parent == nil {
-		return fmt.Errorf("Unknown symbol '%s'", k)
-	}
-	return e.parent.Set(k, v)
-}
-
-// DefineGlobal defines symbol in global scope.
-func (e *Env) DefineGlobal(k string, v interface{}) error {
-	if e.parent == nil {
-		return e.Define(k, v)
-	}
-	return e.parent.DefineGlobal(k, v)
-}
-
-// DefineType defines type which specifis symbol in global scope.
-func (e *Env) DefineType(k string, t interface{}) error {
-	if strings.Contains(k, ".") {
-		return fmt.Errorf("Unknown symbol '%s'", k)
-	}
-	global := e
-	keys := []string{k}
-
-	e.RLock()
-	for global.parent != nil {
-		if global.name != "" {
-			keys = append(keys, global.name)
-		}
-		global = global.parent
-	}
-	e.RUnlock()
-
-	for i, j := 0, len(keys)-1; i < j; i, j = i+1, j-1 {
-		keys[i], keys[j] = keys[j], keys[i]
-	}
-
-	typ, ok := t.(reflect.Type)
-	if !ok {
-		typ = reflect.TypeOf(t)
-	}
-
-	global.Lock()
-	global.typ[strings.Join(keys, ".")] = typ
-	global.Unlock()
-
-	return nil
-}
-
-// Define defines symbol in current scope.
-func (e *Env) Define(k string, v interface{}) error {
-	if strings.Contains(k, ".") {
-		return fmt.Errorf("Unknown symbol '%s'", k)
-	}
-	val, ok := v.(reflect.Value)
-	if !ok {
-		val = reflect.ValueOf(v)
-	}
-
-	e.Lock()
-	e.env[k] = val
-	e.Unlock()
-
-	return nil
-}
-
-// String return the name of current scope.
-func (e *Env) String() string {
-	e.RLock()
-	defer e.RUnlock()
-
-	return e.name
-}
-
-// Dump show symbol values in the scope.
-func (e *Env) Dump() {
-	e.RLock()
-	for k, v := range e.env {
-		fmt.Printf("%v = %#v\n", k, v)
-	}
-	e.RUnlock()
-}
-
-// Execute parses and runs source in current scope.
-func (e *Env) Execute(src string) (reflect.Value, error) {
-	stmts, err := parser.ParseSrc(src)
-	if err != nil {
-		return NilValue, err
-	}
-	return Run(stmts, e)
-}