Add test + sure up logic

- Added tests for import + export
- added some more checks and error types, such as ensuring the plural rule you are adding belongs to the locale.

errors.go

@@ -94,6 +94,27 @@ func (e *ErrMissingPluralTranslation) Error() string {
 	return fmt.Sprintf("error: missing '%s' plural rule '%s' for translation with key '%s'", e.translationType, e.rule, e.key)
 }
 
+// ErrMissingBracket is the error representing a missing bracket in a translation
+// eg. This is a {0 <-- missing ending '}'
+type ErrMissingBracket struct {
+}
+
+// Error returns ErrMissingBracket error message
+func (e *ErrMissingBracket) Error() string {
+	return fmt.Sprint("error: missing bracket, '{' or '}', in translation")
+}
+
+// ErrBadParamSyntax is the error representing a bad parameter definition in a translation
+// eg. This is a {must-be-int}
+type ErrBadParamSyntax struct {
+	param string
+}
+
+// Error returns ErrBadParamSyntax error message
+func (e *ErrBadParamSyntax) Error() string {
+	return fmt.Sprintf("error: bad parameter syntax, missing parameter '%s'", e.param)
+}
+
 // import/export errors
 
 // ErrMissingLocale is the error representing an expected locale that could

import_export.go

@@ -154,20 +154,29 @@ func (t *UniversalTranslator) Import(format ExportFormat, dirnameOrFilename stri
 	}
 
 	// recursively go through directory
-
 	walker := func(path string, info os.FileInfo, err error) error {
 
 		if info.IsDir() {
 			return nil
 		}
 
-		return processFn(dirnameOrFilename)
+		switch format {
+		case JSON:
+			// skip non JSON files
+			if filepath.Ext(info.Name()) != ".json" {
+				return nil
+			}
+		}
+
+		return processFn(path)
 	}
 
 	return filepath.Walk(dirnameOrFilename, walker)
 }
 
-// ImportByReader imports a files contexts
+// ImportByReader imports the the translations found within the contents read from the supplied reader.
+//
+// NOTE: generally used when assets have been embedded into the binary and are already in memory.
 func (t *UniversalTranslator) ImportByReader(format ExportFormat, reader io.Reader) error {
 
 	b, err := ioutil.ReadAll(reader)
@@ -196,19 +205,29 @@ func (t *UniversalTranslator) ImportByReader(format ExportFormat, reader io.Read
 		pr := stringToPR(tl.PluralRule)
 
 		if pr == locales.PluralRuleUnknown {
-			return locale.Add(tl.Key, tl.Translation, tl.OverrideExisting)
+
+			err = locale.Add(tl.Key, tl.Translation, tl.OverrideExisting)
+			if err != nil {
+				return err
+			}
+
+			continue
 		}
 
 		switch tl.PluralType {
 		case cardinalType:
-			return locale.AddCardinal(tl.Key, tl.Translation, pr, tl.OverrideExisting)
+			err = locale.AddCardinal(tl.Key, tl.Translation, pr, tl.OverrideExisting)
 		case ordinalType:
-			return locale.AddOrdinal(tl.Key, tl.Translation, pr, tl.OverrideExisting)
+			err = locale.AddOrdinal(tl.Key, tl.Translation, pr, tl.OverrideExisting)
 		case rangeType:
-			return locale.AddRange(tl.Key, tl.Translation, pr, tl.OverrideExisting)
+			err = locale.AddRange(tl.Key, tl.Translation, pr, tl.OverrideExisting)
 		default:
 			return &ErrBadPluralDefinition{tl: tl}
 		}
+
+		if err != nil {
+			return err
+		}
 	}
 
 	return nil

import_export_test.go

@@ -1,5 +1,16 @@
 package ut
 
+import (
+	"fmt"
+	"testing"
+
+	"os"
+
+	"github.com/go-playground/locales"
+	"github.com/go-playground/locales/en"
+	"github.com/go-playground/locales/nl"
+)
+
 // NOTES:
 // - Run "go test" to run tests
 // - Run "gocov test | gocov report" to report on test converage by file
@@ -10,3 +21,718 @@ package ut
 // -- may be a good idea to change to output path to somewherelike /tmp
 // go test -coverprofile cover.out && go tool cover -html=cover.out -o cover.html
 //
+
+func TestExportImportBasic(t *testing.T) {
+
+	e := en.New()
+	uni := New(e, e)
+	en, found := uni.GetTranslator("en") // or fallback if fails to find 'en'
+	if !found {
+		t.Fatalf("Expected '%t' Got '%t'", true, found)
+	}
+
+	translations := []struct {
+		key           interface{}
+		trans         string
+		expected      error
+		expectedError bool
+		override      bool
+	}{
+		{
+			key:      "test_trans",
+			trans:    "Welcome {0}",
+			expected: nil,
+		},
+		{
+			key:      -1,
+			trans:    "Welcome {0}",
+			expected: nil,
+		},
+		{
+			key:      "test_trans2",
+			trans:    "{0} to the {1}.",
+			expected: nil,
+		},
+		{
+			key:      "test_trans3",
+			trans:    "Welcome {0} to the {1}",
+			expected: nil,
+		},
+		{
+			key:      "test_trans4",
+			trans:    "{0}{1}",
+			expected: nil,
+		},
+		{
+			key:           "test_trans",
+			trans:         "{0}{1}",
+			expected:      &ErrConflictingTranslation{key: "test_trans", text: "{0}{1}"},
+			expectedError: true,
+		},
+		{
+			key:           -1,
+			trans:         "{0}{1}",
+			expected:      &ErrConflictingTranslation{key: -1, text: "{0}{1}"},
+			expectedError: true,
+		},
+		{
+			key:      "test_trans",
+			trans:    "Welcome {0} to the {1}.",
+			expected: nil,
+			override: true,
+		},
+	}
+
+	for _, tt := range translations {
+
+		err := en.Add(tt.key, tt.trans, tt.override)
+		if err != tt.expected {
+			if !tt.expectedError {
+				t.Errorf("Expected '%s' Got '%s'", tt.expected, err)
+			} else {
+				if err.Error() != tt.expected.Error() {
+					t.Errorf("Expected '%s' Got '%s'", tt.expected.Error(), err.Error())
+				}
+			}
+		}
+	}
+
+	filename := "testdata/basic-export-test.json"
+
+	uni.Export(JSON, filename)
+
+	uni = New(e, e)
+
+	err := uni.Import(JSON, filename)
+	if err != nil {
+		t.Fatalf("Expected '%v' Got '%s'", nil, err)
+	}
+
+	en, found = uni.GetTranslator("en") // or fallback if fails to find 'en'
+	if !found {
+		t.Fatalf("Expected '%t' Got '%t'", true, found)
+	}
+
+	tests := []struct {
+		key           interface{}
+		params        []string
+		expected      string
+		expectedError bool
+	}{
+		{
+			key:      "test_trans",
+			params:   []string{"Joeybloggs", "The Test"},
+			expected: "Welcome Joeybloggs to the The Test.",
+		},
+		{
+			key:      "test_trans2",
+			params:   []string{"Joeybloggs", "The Test"},
+			expected: "Joeybloggs to the The Test.",
+		},
+		{
+			key:      "test_trans3",
+			params:   []string{"Joeybloggs", "The Test"},
+			expected: "Welcome Joeybloggs to the The Test",
+		},
+		{
+			key:      "test_trans4",
+			params:   []string{"Joeybloggs", "The Test"},
+			expected: "JoeybloggsThe Test",
+		},
+		// bad translation
+		{
+			key:           "non-existant-key",
+			params:        []string{"Joeybloggs", "The Test"},
+			expected:      "",
+			expectedError: true,
+		},
+	}
+
+	for _, tt := range tests {
+
+		s, err := en.T(tt.key, tt.params...)
+		if s != tt.expected {
+			if !tt.expectedError || (tt.expectedError && err != ErrUnknowTranslation) {
+				t.Errorf("Expected '%s' Got '%s'", tt.expected, s)
+			}
+		}
+	}
+}
+
+func TestExportImportCardinal(t *testing.T) {
+
+	e := en.New()
+	uni := New(e, e)
+	en, found := uni.GetTranslator("en")
+	if !found {
+		t.Fatalf("Expected '%t' Got '%t'", true, found)
+	}
+
+	translations := []struct {
+		key           interface{}
+		trans         string
+		rule          locales.PluralRule
+		expected      error
+		expectedError bool
+		override      bool
+	}{
+		// bad translation
+		{
+			key:           "cardinal_test",
+			trans:         "You have a day left.",
+			rule:          locales.PluralRuleOne,
+			expected:      &ErrCardinalTranslation{text: fmt.Sprintf("error: parameter '%s' not found, may want to use 'Add' instead of 'AddCardinal'", paramZero)},
+			expectedError: true,
+		},
+		{
+			key:      "cardinal_test",
+			trans:    "You have {0} day",
+			rule:     locales.PluralRuleOne,
+			expected: nil,
+		},
+		{
+			key:      "cardinal_test",
+			trans:    "You have {0} days left.",
+			rule:     locales.PluralRuleOther,
+			expected: nil,
+		},
+		{
+			key:           "cardinal_test",
+			trans:         "You have {0} days left.",
+			rule:          locales.PluralRuleOther,
+			expected:      &ErrConflictingTranslation{key: "cardinal_test", rule: locales.PluralRuleOther, text: "You have {0} days left."},
+			expectedError: true,
+		},
+		{
+			key:      "cardinal_test",
+			trans:    "You have {0} day left.",
+			rule:     locales.PluralRuleOne,
+			expected: nil,
+			override: true,
+		},
+	}
+
+	for _, tt := range translations {
+
+		err := en.AddCardinal(tt.key, tt.trans, tt.rule, tt.override)
+		if err != tt.expected {
+			if !tt.expectedError || err.Error() != tt.expected.Error() {
+				t.Errorf("Expected '<nil>' Got '%s'", err)
+			}
+		}
+	}
+
+	filename := "testdata/cardinal-export-test.json"
+
+	uni.Export(JSON, filename)
+
+	uni = New(e, e)
+
+	err := uni.Import(JSON, filename)
+	if err != nil {
+		t.Fatalf("Expected '%v' Got '%s'", nil, err)
+	}
+
+	en, found = uni.GetTranslator("en") // or fallback if fails to find 'en'
+	if !found {
+		t.Fatalf("Expected '%t' Got '%t'", true, found)
+	}
+
+	tests := []struct {
+		key           interface{}
+		num           float64
+		digits        uint64
+		param         string
+		expected      string
+		expectedError bool
+	}{
+		{
+			key:      "cardinal_test",
+			num:      1,
+			digits:   0,
+			param:    string(en.FmtNumber(1, 0)),
+			expected: "You have 1 day left.",
+		},
+		// bad translation key
+		{
+			key:           "non-existant",
+			num:           1,
+			digits:        0,
+			param:         string(en.FmtNumber(1, 0)),
+			expected:      "",
+			expectedError: true,
+		},
+	}
+
+	for _, tt := range tests {
+
+		s, err := en.C(tt.key, tt.num, tt.digits, tt.param)
+		if err != nil {
+			if !tt.expectedError && err != ErrUnknowTranslation {
+				t.Errorf("Expected '<nil>' Got '%s'", err)
+			}
+		}
+
+		if s != tt.expected {
+			t.Errorf("Expected '%s' Got '%s'", tt.expected, s)
+		}
+	}
+}
+
+func TestExportImportOrdinal(t *testing.T) {
+
+	e := en.New()
+	uni := New(e, e)
+	en, found := uni.GetTranslator("en")
+	if !found {
+		t.Fatalf("Expected '%t' Got '%t'", true, found)
+	}
+
+	translations := []struct {
+		key           interface{}
+		trans         string
+		rule          locales.PluralRule
+		expected      error
+		expectedError bool
+		override      bool
+	}{
+		// bad translation
+		{
+			key:           "day",
+			trans:         "st",
+			rule:          locales.PluralRuleOne,
+			expected:      &ErrOrdinalTranslation{text: fmt.Sprintf("error: parameter '%s' not found, may want to use 'Add' instead of 'AddOrdinal'", paramZero)},
+			expectedError: true,
+		},
+		{
+			key:      "day",
+			trans:    "{0}sfefewt",
+			rule:     locales.PluralRuleOne,
+			expected: nil,
+		},
+		{
+			key:      "day",
+			trans:    "{0}nd",
+			rule:     locales.PluralRuleTwo,
+			expected: nil,
+		},
+		{
+			key:      "day",
+			trans:    "{0}rd",
+			rule:     locales.PluralRuleFew,
+			expected: nil,
+		},
+		{
+			key:      "day",
+			trans:    "{0}th",
+			rule:     locales.PluralRuleOther,
+			expected: nil,
+		},
+		// bad translation
+		{
+			key:           "day",
+			trans:         "{0}th",
+			rule:          locales.PluralRuleOther,
+			expected:      &ErrConflictingTranslation{key: "day", rule: locales.PluralRuleOther, text: "{0}th"},
+			expectedError: true,
+		},
+		{
+			key:      "day",
+			trans:    "{0}st",
+			rule:     locales.PluralRuleOne,
+			expected: nil,
+			override: true,
+		},
+	}
+
+	for _, tt := range translations {
+
+		err := en.AddOrdinal(tt.key, tt.trans, tt.rule, tt.override)
+		if err != tt.expected {
+			if !tt.expectedError || err.Error() != tt.expected.Error() {
+				t.Errorf("Expected '<nil>' Got '%s'", err)
+			}
+		}
+	}
+
+	filename := "testdata/ordinal-export-test.json"
+
+	uni.Export(JSON, filename)
+
+	uni = New(e, e)
+
+	err := uni.Import(JSON, filename)
+	if err != nil {
+		t.Fatalf("Expected '%v' Got '%s'", nil, err)
+	}
+
+	en, found = uni.GetTranslator("en") // or fallback if fails to find 'en'
+	if !found {
+		t.Fatalf("Expected '%t' Got '%t'", true, found)
+	}
+
+	tests := []struct {
+		key           interface{}
+		num           float64
+		digits        uint64
+		param         string
+		expected      string
+		expectedError bool
+	}{
+		{
+			key:      "day",
+			num:      1,
+			digits:   0,
+			param:    string(en.FmtNumber(1, 0)),
+			expected: "1st",
+		},
+		{
+			key:      "day",
+			num:      2,
+			digits:   0,
+			param:    string(en.FmtNumber(2, 0)),
+			expected: "2nd",
+		},
+		{
+			key:      "day",
+			num:      3,
+			digits:   0,
+			param:    string(en.FmtNumber(3, 0)),
+			expected: "3rd",
+		},
+		{
+			key:      "day",
+			num:      4,
+			digits:   0,
+			param:    string(en.FmtNumber(4, 0)),
+			expected: "4th",
+		},
+		{
+			key:      "day",
+			num:      10258.43,
+			digits:   0,
+			param:    string(en.FmtNumber(10258.43, 0)),
+			expected: "10,258th",
+		},
+		// bad translation
+		{
+			key:           "d-day",
+			num:           10258.43,
+			digits:        0,
+			param:         string(en.FmtNumber(10258.43, 0)),
+			expected:      "",
+			expectedError: true,
+		},
+	}
+
+	for _, tt := range tests {
+
+		s, err := en.O(tt.key, tt.num, tt.digits, tt.param)
+		if err != nil {
+			if !tt.expectedError && err != ErrUnknowTranslation {
+				t.Errorf("Expected '<nil>' Got '%s'", err)
+			}
+		}
+
+		if s != tt.expected {
+			t.Errorf("Expected '%s' Got '%s'", tt.expected, s)
+		}
+	}
+}
+
+func TestExportImportRange(t *testing.T) {
+
+	n := nl.New()
+	uni := New(n, n)
+
+	// dutch
+	nl, found := uni.GetTranslator("nl")
+	if !found {
+		t.Fatalf("Expected '%t' Got '%t'", true, found)
+	}
+
+	translations := []struct {
+		key           interface{}
+		trans         string
+		rule          locales.PluralRule
+		expected      error
+		expectedError bool
+		override      bool
+	}{
+		// bad translation
+		{
+			key:           "day",
+			trans:         "er -{1} dag vertrokken",
+			rule:          locales.PluralRuleOne,
+			expected:      &ErrRangeTranslation{text: fmt.Sprintf("error: parameter '%s' not found, are you sure you're adding a Range Translation?", paramZero)},
+			expectedError: true,
+		},
+		// bad translation
+		{
+			key:           "day",
+			trans:         "er {0}- dag vertrokken",
+			rule:          locales.PluralRuleOne,
+			expected:      &ErrRangeTranslation{text: fmt.Sprintf("error: parameter '%s' not found, a Range Translation requires two parameters", paramOne)},
+			expectedError: true,
+		},
+		{
+			key:      "day",
+			trans:    "er {0}-{1} dag",
+			rule:     locales.PluralRuleOne,
+			expected: nil,
+		},
+		{
+			key:      "day",
+			trans:    "er zijn {0}-{1} dagen over",
+			rule:     locales.PluralRuleOther,
+			expected: nil,
+		},
+		// bad translation
+		{
+			key:           "day",
+			trans:         "er zijn {0}-{1} dagen over",
+			rule:          locales.PluralRuleOther,
+			expected:      &ErrConflictingTranslation{key: "day", rule: locales.PluralRuleOther, text: "er zijn {0}-{1} dagen over"},
+			expectedError: true,
+		},
+		{
+			key:      "day",
+			trans:    "er {0}-{1} dag vertrokken",
+			rule:     locales.PluralRuleOne,
+			expected: nil,
+			override: true,
+		},
+	}
+
+	for _, tt := range translations {
+
+		err := nl.AddRange(tt.key, tt.trans, tt.rule, tt.override)
+		if err != tt.expected {
+			if !tt.expectedError || err.Error() != tt.expected.Error() {
+				t.Errorf("Expected '%#v' Got '%s'", tt.expected, err)
+			}
+		}
+	}
+
+	filename := "testdata/range-export-test.json"
+
+	uni.Export(JSON, filename)
+
+	uni = New(n, n)
+
+	err := uni.Import(JSON, filename)
+	if err != nil {
+		t.Fatalf("Expected '%v' Got '%s'", nil, err)
+	}
+
+	nl, found = uni.GetTranslator("nl") // or fallback if fails to find 'en'
+	if !found {
+		t.Fatalf("Expected '%t' Got '%t'", true, found)
+	}
+
+	tests := []struct {
+		key           interface{}
+		num1          float64
+		digits1       uint64
+		num2          float64
+		digits2       uint64
+		param1        string
+		param2        string
+		expected      string
+		expectedError bool
+	}{
+		{
+			key:      "day",
+			num1:     1,
+			digits1:  0,
+			num2:     2,
+			digits2:  0,
+			param1:   string(nl.FmtNumber(1, 0)),
+			param2:   string(nl.FmtNumber(2, 0)),
+			expected: "er zijn 1-2 dagen over",
+		},
+		{
+			key:      "day",
+			num1:     0,
+			digits1:  0,
+			num2:     1,
+			digits2:  0,
+			param1:   string(nl.FmtNumber(0, 0)),
+			param2:   string(nl.FmtNumber(1, 0)),
+			expected: "er 0-1 dag vertrokken",
+		},
+		{
+			key:      "day",
+			num1:     0,
+			digits1:  0,
+			num2:     2,
+			digits2:  0,
+			param1:   string(nl.FmtNumber(0, 0)),
+			param2:   string(nl.FmtNumber(2, 0)),
+			expected: "er zijn 0-2 dagen over",
+		},
+		// bad translations from here
+		{
+			key:           "d-day",
+			num1:          0,
+			digits1:       0,
+			num2:          2,
+			digits2:       0,
+			param1:        string(nl.FmtNumber(0, 0)),
+			param2:        string(nl.FmtNumber(2, 0)),
+			expected:      "",
+			expectedError: true,
+		},
+	}
+
+	for _, tt := range tests {
+
+		s, err := nl.R(tt.key, tt.num1, tt.digits1, tt.num2, tt.digits2, tt.param1, tt.param2)
+		if err != nil {
+			if !tt.expectedError && err != ErrUnknowTranslation {
+				t.Errorf("Expected '<nil>' Got '%s'", err)
+			}
+		}
+
+		if s != tt.expected {
+			t.Errorf("Expected '%s' Got '%s'", tt.expected, s)
+		}
+	}
+}
+
+func TestImportRecursive(t *testing.T) {
+
+	e := en.New()
+	uni := New(e, e)
+
+	dirname := "testdata/nested1"
+	err := uni.Import(JSON, dirname)
+	if err != nil {
+		t.Fatalf("Expected '%v' Got '%s'", nil, err)
+	}
+
+	en, found := uni.GetTranslator("en") // or fallback if fails to find 'en'
+	if !found {
+		t.Fatalf("Expected '%t' Got '%t'", true, found)
+	}
+
+	tests := []struct {
+		key           interface{}
+		params        []string
+		expected      string
+		expectedError bool
+	}{
+		{
+			key:      "test_trans",
+			params:   []string{"Joeybloggs", "The Test"},
+			expected: "Welcome Joeybloggs to the The Test.",
+		},
+		{
+			key:      "test_trans2",
+			params:   []string{"Joeybloggs", "The Test"},
+			expected: "Joeybloggs to the The Test.",
+		},
+		{
+			key:      "test_trans3",
+			params:   []string{"Joeybloggs", "The Test"},
+			expected: "Welcome Joeybloggs to the The Test",
+		},
+		{
+			key:      "test_trans4",
+			params:   []string{"Joeybloggs", "The Test"},
+			expected: "JoeybloggsThe Test",
+		},
+		// bad translation
+		{
+			key:           "non-existant-key",
+			params:        []string{"Joeybloggs", "The Test"},
+			expected:      "",
+			expectedError: true,
+		},
+	}
+
+	for _, tt := range tests {
+
+		s, err := en.T(tt.key, tt.params...)
+		if s != tt.expected {
+			if !tt.expectedError || (tt.expectedError && err != ErrUnknowTranslation) {
+				t.Errorf("Expected '%s' Got '%s'", tt.expected, s)
+			}
+		}
+	}
+}
+
+func TestBadImport(t *testing.T) {
+
+	// test non existant file
+	e := en.New()
+	uni := New(e, e)
+
+	filename := "testdata/non-existant-file.json"
+	expected := "stat testdata/non-existant-file.json: no such file or directory"
+	err := uni.Import(JSON, filename)
+	if err == nil || err.Error() != expected {
+		t.Fatalf("Expected '%s' Got '%s'", expected, err)
+	}
+
+	// test bad parameter basic translation
+	filename = "testdata/bad-translation1.json"
+	expected = "error: bad parameter syntax, missing parameter '{0}'"
+	err = uni.Import(JSON, filename)
+	if err == nil || err.Error() != expected {
+		t.Fatalf("Expected '%s' Got '%s'", expected, err)
+	}
+
+	// test missing bracket basic translation
+	filename = "testdata/bad-translation2.json"
+	expected = "error: missing bracket, '{' or '}', in translation"
+	err = uni.Import(JSON, filename)
+	if err == nil || err.Error() != expected {
+		t.Fatalf("Expected '%s' Got '%s'", expected, err)
+	}
+
+	// test missing locale basic translation
+	filename = "testdata/bad-translation3.json"
+	expected = "error: locale 'nl' not registered."
+	err = uni.Import(JSON, filename)
+	if err == nil || err.Error() != expected {
+		t.Fatalf("Expected '%s' Got '%s'", expected, err)
+	}
+
+	// test bad plural definition
+	filename = "testdata/bad-translation4.json"
+	expected = "error: bad plural definition 'ut.translation{Locale:\"en\", Key:\"cardinal_test\", Translation:\"You have {0} day left.\", PluralType:\"NotAPluralType\", PluralRule:\"One\", OverrideExisting:false}'"
+	err = uni.Import(JSON, filename)
+	if err == nil || err.Error() != expected {
+		t.Fatalf("Expected '%s' Got '%s'", expected, err)
+	}
+
+	// test bad plural rule for locale
+	filename = "testdata/bad-translation5.json"
+	expected = "error: cardinal plural rule 'Many' does not exist for locale 'en'"
+	err = uni.Import(JSON, filename)
+	if err == nil || err.Error() != expected {
+		t.Fatalf("Expected '%s' Got '%s'", expected, err)
+	}
+
+	// test invalid JSON
+	filename = "testdata/bad-translation6.json"
+	expected = "invalid character ']' after object key:value pair"
+	err = uni.Import(JSON, filename)
+	if err == nil || err.Error() != expected {
+		t.Fatalf("Expected '%s' Got '%s'", expected, err)
+	}
+
+	// test bad io.Reader
+	f, err := os.Open(filename)
+	if err != nil {
+		t.Fatalf("Expected '%v' Got '%s'", nil, err)
+	}
+	f.Close()
+
+	expected = "read testdata/bad-translation6.json: bad file descriptor"
+	err = uni.ImportByReader(JSON, f)
+	if err == nil || err.Error() != expected {
+		t.Fatalf("Expected '%s' Got '%s'", expected, err)
+	}
+}

testdata/.gitignore

@@ -1,3 +1,11 @@
 *
 
-!.gitignore
+!.gitignore
+!*/
+!bad-translation1.json
+!bad-translation2.json
+!bad-translation3.json
+!bad-translation4.json
+!bad-translation5.json
+!bad-translation6.json
+!/nested1/**

testdata/bad-translation1.json

@@ -0,0 +1,7 @@
+[
+    {
+        "locale": "en",
+        "key": "test_trans3",
+        "trans": "Welcome {lettersnotpermitted} to the {1}"
+    }
+]

testdata/bad-translation2.json

@@ -0,0 +1,7 @@
+[
+    {
+        "locale": "en",
+        "key": "test_trans3",
+        "trans": "Welcome {0 to the {1}"
+    }
+]

testdata/bad-translation3.json

@@ -0,0 +1,7 @@
+[
+    {
+        "locale": "nl",
+        "key": "test_trans3",
+        "trans": "Welcome {0 to the {1}"
+    }
+]

testdata/bad-translation4.json

@@ -0,0 +1,9 @@
+[
+    {
+        "locale": "en",
+        "key": "cardinal_test",
+        "trans": "You have {0} day left.",
+        "type": "NotAPluralType",
+        "rule": "One"
+    }
+]

testdata/bad-translation5.json

@@ -0,0 +1,9 @@
+[
+    {
+        "locale": "en",
+        "key": "cardinal_test",
+        "trans": "You have {0} day left.",
+        "type": "Cardinal",
+        "rule": "Many"
+    }
+]

testdata/bad-translation6.json

@@ -0,0 +1,9 @@
+[
+    {
+        "locale": "en",
+        "key": "cardinal_test",
+        "trans": "You have {0} day left.",
+        "type": "Cardinal",
+        "rule": "Many"
+    
+]

testdata/nested1/nested1.json

@@ -0,0 +1,12 @@
+[
+    {
+        "locale": "en",
+        "key": -1,
+        "trans": "Welcome {0}"
+    },
+    {
+        "locale": "en",
+        "key": "test_trans2",
+        "trans": "{0} to the {1}."
+    }
+]

testdata/nested1/nested2/nested2.json

@@ -0,0 +1,17 @@
+[
+    {
+        "locale": "en",
+        "key": "test_trans3",
+        "trans": "Welcome {0} to the {1}"
+    },
+    {
+        "locale": "en",
+        "key": "test_trans4",
+        "trans": "{0}{1}"
+    },
+    {
+        "locale": "en",
+        "key": "test_trans",
+        "trans": "Welcome {0} to the {1}."
+    }
+]

translator.go

@@ -101,23 +101,28 @@ func (t *translator) Add(key interface{}, text string, override bool) error {
 		return &ErrConflictingTranslation{key: key, text: text}
 	}
 
+	lb := strings.Count(text, "{")
+	rb := strings.Count(text, "}")
+
+	if lb != rb {
+		return &ErrMissingBracket{}
+	}
+
 	trans := &transText{
 		text: text,
 	}
 
-	var i int
 	var idx int
 
-	for {
+	for i := 0; i < lb; i++ {
 		s := "{" + strconv.Itoa(i) + "}"
 		idx = strings.Index(text, s)
 		if idx == -1 {
-			break
+			return &ErrBadParamSyntax{param: s}
 		}
 
 		trans.indexes = append(trans.indexes, idx)
 		trans.indexes = append(trans.indexes, idx+len(s))
-		i++
 	}
 
 	t.translations[key] = trans
@@ -132,6 +137,20 @@ func (t *translator) Add(key interface{}, text string, override bool) error {
 // eg. in locale 'en' one: '{0} day left' other: '{0} days left'
 func (t *translator) AddCardinal(key interface{}, text string, rule locales.PluralRule, override bool) error {
 
+	var verified bool
+
+	// verify plural rule exists for locale
+	for _, pr := range t.PluralsCardinal() {
+		if pr == rule {
+			verified = true
+			break
+		}
+	}
+
+	if !verified {
+		return &ErrCardinalTranslation{text: fmt.Sprintf("error: cardinal plural rule '%s' does not exist for locale '%s'", rule, t.Locale())}
+	}
+
 	tarr, ok := t.cardinalTanslations[key]
 	if ok {
 		// verify not adding a conflicting record
@@ -170,6 +189,20 @@ func (t *translator) AddCardinal(key interface{}, text string, rule locales.Plur
 // eg. in locale 'en' one: '{0}st day of spring' other: '{0}nd day of spring' - 1st, 2nd, 3rd...
 func (t *translator) AddOrdinal(key interface{}, text string, rule locales.PluralRule, override bool) error {
 
+	var verified bool
+
+	// verify plural rule exists for locale
+	for _, pr := range t.PluralsOrdinal() {
+		if pr == rule {
+			verified = true
+			break
+		}
+	}
+
+	if !verified {
+		return &ErrOrdinalTranslation{text: fmt.Sprintf("error: ordinal plural rule '%s' does not exist for locale '%s'", rule, t.Locale())}
+	}
+
 	tarr, ok := t.ordinalTanslations[key]
 	if ok {
 		// verify not adding a conflicting record
@@ -206,6 +239,20 @@ func (t *translator) AddOrdinal(key interface{}, text string, rule locales.Plura
 // eg. in locale 'nl' one: '{0}-{1} day left' other: '{0}-{1} days left'
 func (t *translator) AddRange(key interface{}, text string, rule locales.PluralRule, override bool) error {
 
+	var verified bool
+
+	// verify plural rule exists for locale
+	for _, pr := range t.PluralsRange() {
+		if pr == rule {
+			verified = true
+			break
+		}
+	}
+
+	if !verified {
+		return &ErrRangeTranslation{text: fmt.Sprintf("error: range plural rule '%s' does not exist for locale '%s'", rule, t.Locale())}
+	}
+
 	tarr, ok := t.rangeTanslations[key]
 	if ok {
 		// verify not adding a conflicting record

translator_test.go

@@ -166,6 +166,14 @@ func TestCardinalTranslation(t *testing.T) {
 			expected:      &ErrCardinalTranslation{text: fmt.Sprintf("error: parameter '%s' not found, may want to use 'Add' instead of 'AddCardinal'", paramZero)},
 			expectedError: true,
 		},
+		// bad translation
+		{
+			key:           "cardinal_test",
+			trans:         "You have a day left few.",
+			rule:          locales.PluralRuleFew,
+			expected:      &ErrCardinalTranslation{text: fmt.Sprintf("error: cardinal plural rule '%s' does not exist for locale '%s'", locales.PluralRuleFew, en.Locale())},
+			expectedError: true,
+		},
 		{
 			key:      "cardinal_test",
 			trans:    "You have {0} day",
@@ -243,8 +251,6 @@ func TestCardinalTranslation(t *testing.T) {
 			t.Errorf("Expected '%s' Got '%s'", tt.expected, s)
 		}
 	}
-
-	uni.Export(JSON, "test.json")
 }
 
 func TestOrdinalTranslation(t *testing.T) {
@@ -272,6 +278,14 @@ func TestOrdinalTranslation(t *testing.T) {
 			expected:      &ErrOrdinalTranslation{text: fmt.Sprintf("error: parameter '%s' not found, may want to use 'Add' instead of 'AddOrdinal'", paramZero)},
 			expectedError: true,
 		},
+		// bad translation
+		{
+			key:           "day",
+			trans:         "st",
+			rule:          locales.PluralRuleMany,
+			expected:      &ErrOrdinalTranslation{text: fmt.Sprintf("error: ordinal plural rule '%s' does not exist for locale '%s'", locales.PluralRuleMany, en.Locale())},
+			expectedError: true,
+		},
 		{
 			key:      "day",
 			trans:    "{0}sfefewt",
@@ -420,6 +434,14 @@ func TestRangeTranslation(t *testing.T) {
 			expectedError: true,
 		},
 		// bad translation
+		{
+			key:           "day",
+			trans:         "er {0}- dag vertrokken",
+			rule:          locales.PluralRuleMany,
+			expected:      &ErrRangeTranslation{text: fmt.Sprintf("error: range plural rule '%s' does not exist for locale '%s'", locales.PluralRuleMany, nl.Locale())},
+			expectedError: true,
+		},
+		// bad translation
 		{
 			key:           "day",
 			trans:         "er {0}- dag vertrokken",