From f6ca641bf402d3756b4b839610dc3db542834d52 Mon Sep 17 00:00:00 2001 From: Alasdair Mercer Date: Fri, 10 Feb 2017 11:48:40 +0000 Subject: [PATCH 1/6] New translations --- src/main/resources/Verifier_de_DE.properties | 153 +++++++++++++++++++ 1 file changed, 153 insertions(+) create mode 100644 src/main/resources/Verifier_de_DE.properties diff --git a/src/main/resources/Verifier_de_DE.properties b/src/main/resources/Verifier_de_DE.properties new file mode 100644 index 0000000..4792c53 --- /dev/null +++ b/src/main/resources/Verifier_de_DE.properties @@ -0,0 +1,153 @@ +#X-Generator: crowdin.com +# Copyright (C) 2017 Alasdair Mercer, Skelp +# +# Permission is hereby granted, free of charge, to any person obtaining a copy +# of this software and associated documentation files (the "Software"), to deal +# in the Software without restriction, including without limitation the rights +# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +# copies of the Software, and to permit persons to whom the Software is +# furnished to do so, subject to the following conditions: +# +# The above copyright notice and this permission notice shall be included in all +# copies or substantial portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +# SOFTWARE. + +io.skelp.verifier.message.ResourceBundleMessageSource.default.message.negated=be invalid +io.skelp.verifier.message.ResourceBundleMessageSource.default.message.normal=be valid +io.skelp.verifier.message.ResourceBundleMessageSource.default.name=Value +io.skelp.verifier.message.ResourceBundleMessageSource.message.negated={0} must not {1}\: {2} +io.skelp.verifier.message.ResourceBundleMessageSource.message.normal={0} must {1}\: {2} + +io.skelp.verifier.AbstractCustomVerifier.equalTo=be equal to ''{0}'' +io.skelp.verifier.AbstractCustomVerifier.equalToAny=be equal to any {0} +io.skelp.verifier.AbstractCustomVerifier.hashedAs=have hash code ''{0,number,integer}'' +io.skelp.verifier.AbstractCustomVerifier.instanceOf=be an instance of ''{0}'' +io.skelp.verifier.AbstractCustomVerifier.instanceOfAll=be an instance of all {0} +io.skelp.verifier.AbstractCustomVerifier.instanceOfAny=be an instance of any {0} +io.skelp.verifier.AbstractCustomVerifier.nulled=be null +io.skelp.verifier.AbstractCustomVerifier.sameAs=be same as ''{0}'' +io.skelp.verifier.AbstractCustomVerifier.sameAsAny=be same as any {0} + +io.skelp.verifier.type.base.BaseCollectionVerifier.contain=contain ''{0}'' +io.skelp.verifier.type.base.BaseCollectionVerifier.containAll=contain all {0} +io.skelp.verifier.type.base.BaseCollectionVerifier.containAny=contain any {0} +io.skelp.verifier.type.base.BaseCollectionVerifier.empty=be empty +io.skelp.verifier.type.base.BaseCollectionVerifier.sizeOf=have a size of ''{0,number,integer}'' + +io.skelp.verifier.type.base.BaseComparableVerifier.between=be between ''{0}'' and ''{1}'' (inclusive) +io.skelp.verifier.type.base.BaseComparableVerifier.betweenExclusive=be between ''{0}'' and ''{1}'' (exclusive) +io.skelp.verifier.type.base.BaseComparableVerifier.greaterThan=be greater than ''{0}'' +io.skelp.verifier.type.base.BaseComparableVerifier.greaterThanOrEqualTo=be greater than or equal to ''{0}'' +io.skelp.verifier.type.base.BaseComparableVerifier.lessThan=be less than ''{0}'' +io.skelp.verifier.type.base.BaseComparableVerifier.lessThanOrEqualTo=be less than or equal to ''{0}'' + +io.skelp.verifier.type.base.BaseNumberVerifier.even=be even +io.skelp.verifier.type.base.BaseNumberVerifier.negative=be negative +io.skelp.verifier.type.base.BaseNumberVerifier.odd=be odd +io.skelp.verifier.type.base.BaseNumberVerifier.one=be one +io.skelp.verifier.type.base.BaseNumberVerifier.positive=be positive +io.skelp.verifier.type.base.BaseNumberVerifier.zero=be zero + +io.skelp.verifier.type.base.BaseSortableCollectionVerifier.sortedBy=be sorted by ''{0}'' + +io.skelp.verifier.type.base.BaseTimeVerifier.sameDayAs=be same day as ''{0}'' +io.skelp.verifier.type.base.BaseTimeVerifier.sameEraAs=be same era as ''{0}'' +io.skelp.verifier.type.base.BaseTimeVerifier.sameHourAs=be same hour as ''{0}'' +io.skelp.verifier.type.base.BaseTimeVerifier.sameMinuteAs=be same minute as ''{0}'' +io.skelp.verifier.type.base.BaseTimeVerifier.sameMonthAs=be same month as ''{0}'' +io.skelp.verifier.type.base.BaseTimeVerifier.sameSecondAs=be same second as ''{0}'' +io.skelp.verifier.type.base.BaseTimeVerifier.sameTimeAs=be same time as ''{0}'' +io.skelp.verifier.type.base.BaseTimeVerifier.sameWeekAs=be same week as ''{0}'' +io.skelp.verifier.type.base.BaseTimeVerifier.sameYearAs=be same year as ''{0}'' + +io.skelp.verifier.type.base.BaseTruthVerifier.falsy=be falsy +io.skelp.verifier.type.base.BaseTruthVerifier.truthy=be truthy + +io.skelp.verifier.type.CharacterVerifier.alpha=be a letter +io.skelp.verifier.type.CharacterVerifier.alphanumeric=be a letter or digit +io.skelp.verifier.type.CharacterVerifier.ascii=be ASCII +io.skelp.verifier.type.CharacterVerifier.asciiAlpha=be an ASCII letter +io.skelp.verifier.type.CharacterVerifier.asciiAlphaLowerCase=be an ASCII lower case letter +io.skelp.verifier.type.CharacterVerifier.asciiAlphaUpperCase=be an ASCII upper case letter +io.skelp.verifier.type.CharacterVerifier.asciiAlphanumeric=be an ASCII letter or digit +io.skelp.verifier.type.CharacterVerifier.asciiControl=be an ASCII control +io.skelp.verifier.type.CharacterVerifier.asciiNumeric=be an ASCII digit +io.skelp.verifier.type.CharacterVerifier.asciiPrintable=be ASCII printable +io.skelp.verifier.type.CharacterVerifier.lowerCase=be lower case +io.skelp.verifier.type.CharacterVerifier.numeric=be a digit +io.skelp.verifier.type.CharacterVerifier.upperCase=be upper case +io.skelp.verifier.type.CharacterVerifier.whitespace=be whitespace + +io.skelp.verifier.type.ClassVerifier.annotated=be annotated +io.skelp.verifier.type.ClassVerifier.annotatedWith=be annotated with ''{0}'' +io.skelp.verifier.type.ClassVerifier.annotatedWithAll=be annotated with all {0} +io.skelp.verifier.type.ClassVerifier.annotatedWithAny=be annotated with any {0} +io.skelp.verifier.type.ClassVerifier.annotation=be an annotation +io.skelp.verifier.type.ClassVerifier.anonymous=be anonymous +io.skelp.verifier.type.ClassVerifier.array=be an array +io.skelp.verifier.type.ClassVerifier.assignableFrom=be assignable from ''{0}'' +io.skelp.verifier.type.ClassVerifier.assignableFromAll=be assignable from all {0} +io.skelp.verifier.type.ClassVerifier.assignableFromAny=be assignable from any {0} +io.skelp.verifier.type.ClassVerifier.enumeration=be an enum +io.skelp.verifier.type.ClassVerifier.interfaced=be an interface +io.skelp.verifier.type.ClassVerifier.nested=be nested +io.skelp.verifier.type.ClassVerifier.primitive=be a primitive +io.skelp.verifier.type.ClassVerifier.primitiveOrWrapper=be a primitive or primitive wrapper +io.skelp.verifier.type.ClassVerifier.primitiveWrapper=be a primitive wrapper + +io.skelp.verifier.type.LocaleVerifier.available=be available +io.skelp.verifier.type.LocaleVerifier.country=be country ''{0}'' +io.skelp.verifier.type.LocaleVerifier.defaulted=be default +io.skelp.verifier.type.LocaleVerifier.language=be language ''{0}'' +io.skelp.verifier.type.LocaleVerifier.script=be script ''{0}'' +io.skelp.verifier.type.LocaleVerifier.variant=be variant ''{0}'' + +io.skelp.verifier.type.MapVerifier.containAllKeys=contain all keys {0} +io.skelp.verifier.type.MapVerifier.containAnyKey=contain any key {0} +io.skelp.verifier.type.MapVerifier.containKey=contain key ''{0}'' + +io.skelp.verifier.type.StringVerifier.alpha=contain only letters +io.skelp.verifier.type.StringVerifier.alphaSpace=contain only letters or space +io.skelp.verifier.type.StringVerifier.alphanumeric=contain only letters or digits +io.skelp.verifier.type.StringVerifier.alphanumericSpace=contain only letters or digits or space +io.skelp.verifier.type.StringVerifier.asciiPrintable=contain only ASCII printable characters +io.skelp.verifier.type.StringVerifier.blank=be blank +io.skelp.verifier.type.StringVerifier.contain=contain ''{0}'' +io.skelp.verifier.type.StringVerifier.containAll=contain all {0} +io.skelp.verifier.type.StringVerifier.containAllIgnoreCase=contain all {0} (ignore case) +io.skelp.verifier.type.StringVerifier.containAny=contain any {0} +io.skelp.verifier.type.StringVerifier.containAnyIgnoreCase=contain any {0} (ignore case) +io.skelp.verifier.type.StringVerifier.containIgnoreCase=contain ''{0}'' (ignore case) +io.skelp.verifier.type.StringVerifier.empty=be empty +io.skelp.verifier.type.StringVerifier.endWith=end with ''{0}'' +io.skelp.verifier.type.StringVerifier.endWithAny=end with any {0} +io.skelp.verifier.type.StringVerifier.endWithAnyIgnoreCase=end with any {0} (ignore case) +io.skelp.verifier.type.StringVerifier.endWithIgnoreCase=end with ''{0}'' (ignore case) +io.skelp.verifier.type.StringVerifier.equalToAnyIgnoreCase=be equal to any {0} (ignore case) +io.skelp.verifier.type.StringVerifier.equalToIgnoreCase=be equal to ''{0}'' (ignore case) +io.skelp.verifier.type.StringVerifier.lowerCase=be all lower case +io.skelp.verifier.type.StringVerifier.match=match ''{0}'' +io.skelp.verifier.type.StringVerifier.matchAll=match all {0} +io.skelp.verifier.type.StringVerifier.matchAny=match any {0} +io.skelp.verifier.type.StringVerifier.numeric=contain only digits +io.skelp.verifier.type.StringVerifier.numericSpace=contain only digits or space +io.skelp.verifier.type.StringVerifier.sizeOf=have a size of ''{0,number,integer}'' +io.skelp.verifier.type.StringVerifier.startWith=start with ''{0}'' +io.skelp.verifier.type.StringVerifier.startWithAny=start with any {0} +io.skelp.verifier.type.StringVerifier.startWithAnyIgnoreCase=start with any {0} (ignore case) +io.skelp.verifier.type.StringVerifier.startWithIgnoreCase=start with ''{0}'' (ignore case) +io.skelp.verifier.type.StringVerifier.upperCase=be all upper case + +io.skelp.verifier.type.ThrowableVerifier.causedBy=have been caused by ''{0}'' +io.skelp.verifier.type.ThrowableVerifier.causedByAll=have been caused by all {0} +io.skelp.verifier.type.ThrowableVerifier.causedByAny=have been caused by any {0} +io.skelp.verifier.type.ThrowableVerifier.checked=be checked +io.skelp.verifier.type.ThrowableVerifier.message=have message ''{0}'' +io.skelp.verifier.type.ThrowableVerifier.unchecked=be unchecked \ No newline at end of file From f85cda8c27c3eee4fada7e69a01c3c82a4ef3eb3 Mon Sep 17 00:00:00 2001 From: Alasdair Mercer Date: Fri, 10 Feb 2017 11:48:42 +0000 Subject: [PATCH 2/6] New translations --- src/main/resources/Verifier_fr_FR.properties | 153 +++++++++++++++++++ 1 file changed, 153 insertions(+) create mode 100644 src/main/resources/Verifier_fr_FR.properties diff --git a/src/main/resources/Verifier_fr_FR.properties b/src/main/resources/Verifier_fr_FR.properties new file mode 100644 index 0000000..4792c53 --- /dev/null +++ b/src/main/resources/Verifier_fr_FR.properties @@ -0,0 +1,153 @@ +#X-Generator: crowdin.com +# Copyright (C) 2017 Alasdair Mercer, Skelp +# +# Permission is hereby granted, free of charge, to any person obtaining a copy +# of this software and associated documentation files (the "Software"), to deal +# in the Software without restriction, including without limitation the rights +# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +# copies of the Software, and to permit persons to whom the Software is +# furnished to do so, subject to the following conditions: +# +# The above copyright notice and this permission notice shall be included in all +# copies or substantial portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +# SOFTWARE. + +io.skelp.verifier.message.ResourceBundleMessageSource.default.message.negated=be invalid +io.skelp.verifier.message.ResourceBundleMessageSource.default.message.normal=be valid +io.skelp.verifier.message.ResourceBundleMessageSource.default.name=Value +io.skelp.verifier.message.ResourceBundleMessageSource.message.negated={0} must not {1}\: {2} +io.skelp.verifier.message.ResourceBundleMessageSource.message.normal={0} must {1}\: {2} + +io.skelp.verifier.AbstractCustomVerifier.equalTo=be equal to ''{0}'' +io.skelp.verifier.AbstractCustomVerifier.equalToAny=be equal to any {0} +io.skelp.verifier.AbstractCustomVerifier.hashedAs=have hash code ''{0,number,integer}'' +io.skelp.verifier.AbstractCustomVerifier.instanceOf=be an instance of ''{0}'' +io.skelp.verifier.AbstractCustomVerifier.instanceOfAll=be an instance of all {0} +io.skelp.verifier.AbstractCustomVerifier.instanceOfAny=be an instance of any {0} +io.skelp.verifier.AbstractCustomVerifier.nulled=be null +io.skelp.verifier.AbstractCustomVerifier.sameAs=be same as ''{0}'' +io.skelp.verifier.AbstractCustomVerifier.sameAsAny=be same as any {0} + +io.skelp.verifier.type.base.BaseCollectionVerifier.contain=contain ''{0}'' +io.skelp.verifier.type.base.BaseCollectionVerifier.containAll=contain all {0} +io.skelp.verifier.type.base.BaseCollectionVerifier.containAny=contain any {0} +io.skelp.verifier.type.base.BaseCollectionVerifier.empty=be empty +io.skelp.verifier.type.base.BaseCollectionVerifier.sizeOf=have a size of ''{0,number,integer}'' + +io.skelp.verifier.type.base.BaseComparableVerifier.between=be between ''{0}'' and ''{1}'' (inclusive) +io.skelp.verifier.type.base.BaseComparableVerifier.betweenExclusive=be between ''{0}'' and ''{1}'' (exclusive) +io.skelp.verifier.type.base.BaseComparableVerifier.greaterThan=be greater than ''{0}'' +io.skelp.verifier.type.base.BaseComparableVerifier.greaterThanOrEqualTo=be greater than or equal to ''{0}'' +io.skelp.verifier.type.base.BaseComparableVerifier.lessThan=be less than ''{0}'' +io.skelp.verifier.type.base.BaseComparableVerifier.lessThanOrEqualTo=be less than or equal to ''{0}'' + +io.skelp.verifier.type.base.BaseNumberVerifier.even=be even +io.skelp.verifier.type.base.BaseNumberVerifier.negative=be negative +io.skelp.verifier.type.base.BaseNumberVerifier.odd=be odd +io.skelp.verifier.type.base.BaseNumberVerifier.one=be one +io.skelp.verifier.type.base.BaseNumberVerifier.positive=be positive +io.skelp.verifier.type.base.BaseNumberVerifier.zero=be zero + +io.skelp.verifier.type.base.BaseSortableCollectionVerifier.sortedBy=be sorted by ''{0}'' + +io.skelp.verifier.type.base.BaseTimeVerifier.sameDayAs=be same day as ''{0}'' +io.skelp.verifier.type.base.BaseTimeVerifier.sameEraAs=be same era as ''{0}'' +io.skelp.verifier.type.base.BaseTimeVerifier.sameHourAs=be same hour as ''{0}'' +io.skelp.verifier.type.base.BaseTimeVerifier.sameMinuteAs=be same minute as ''{0}'' +io.skelp.verifier.type.base.BaseTimeVerifier.sameMonthAs=be same month as ''{0}'' +io.skelp.verifier.type.base.BaseTimeVerifier.sameSecondAs=be same second as ''{0}'' +io.skelp.verifier.type.base.BaseTimeVerifier.sameTimeAs=be same time as ''{0}'' +io.skelp.verifier.type.base.BaseTimeVerifier.sameWeekAs=be same week as ''{0}'' +io.skelp.verifier.type.base.BaseTimeVerifier.sameYearAs=be same year as ''{0}'' + +io.skelp.verifier.type.base.BaseTruthVerifier.falsy=be falsy +io.skelp.verifier.type.base.BaseTruthVerifier.truthy=be truthy + +io.skelp.verifier.type.CharacterVerifier.alpha=be a letter +io.skelp.verifier.type.CharacterVerifier.alphanumeric=be a letter or digit +io.skelp.verifier.type.CharacterVerifier.ascii=be ASCII +io.skelp.verifier.type.CharacterVerifier.asciiAlpha=be an ASCII letter +io.skelp.verifier.type.CharacterVerifier.asciiAlphaLowerCase=be an ASCII lower case letter +io.skelp.verifier.type.CharacterVerifier.asciiAlphaUpperCase=be an ASCII upper case letter +io.skelp.verifier.type.CharacterVerifier.asciiAlphanumeric=be an ASCII letter or digit +io.skelp.verifier.type.CharacterVerifier.asciiControl=be an ASCII control +io.skelp.verifier.type.CharacterVerifier.asciiNumeric=be an ASCII digit +io.skelp.verifier.type.CharacterVerifier.asciiPrintable=be ASCII printable +io.skelp.verifier.type.CharacterVerifier.lowerCase=be lower case +io.skelp.verifier.type.CharacterVerifier.numeric=be a digit +io.skelp.verifier.type.CharacterVerifier.upperCase=be upper case +io.skelp.verifier.type.CharacterVerifier.whitespace=be whitespace + +io.skelp.verifier.type.ClassVerifier.annotated=be annotated +io.skelp.verifier.type.ClassVerifier.annotatedWith=be annotated with ''{0}'' +io.skelp.verifier.type.ClassVerifier.annotatedWithAll=be annotated with all {0} +io.skelp.verifier.type.ClassVerifier.annotatedWithAny=be annotated with any {0} +io.skelp.verifier.type.ClassVerifier.annotation=be an annotation +io.skelp.verifier.type.ClassVerifier.anonymous=be anonymous +io.skelp.verifier.type.ClassVerifier.array=be an array +io.skelp.verifier.type.ClassVerifier.assignableFrom=be assignable from ''{0}'' +io.skelp.verifier.type.ClassVerifier.assignableFromAll=be assignable from all {0} +io.skelp.verifier.type.ClassVerifier.assignableFromAny=be assignable from any {0} +io.skelp.verifier.type.ClassVerifier.enumeration=be an enum +io.skelp.verifier.type.ClassVerifier.interfaced=be an interface +io.skelp.verifier.type.ClassVerifier.nested=be nested +io.skelp.verifier.type.ClassVerifier.primitive=be a primitive +io.skelp.verifier.type.ClassVerifier.primitiveOrWrapper=be a primitive or primitive wrapper +io.skelp.verifier.type.ClassVerifier.primitiveWrapper=be a primitive wrapper + +io.skelp.verifier.type.LocaleVerifier.available=be available +io.skelp.verifier.type.LocaleVerifier.country=be country ''{0}'' +io.skelp.verifier.type.LocaleVerifier.defaulted=be default +io.skelp.verifier.type.LocaleVerifier.language=be language ''{0}'' +io.skelp.verifier.type.LocaleVerifier.script=be script ''{0}'' +io.skelp.verifier.type.LocaleVerifier.variant=be variant ''{0}'' + +io.skelp.verifier.type.MapVerifier.containAllKeys=contain all keys {0} +io.skelp.verifier.type.MapVerifier.containAnyKey=contain any key {0} +io.skelp.verifier.type.MapVerifier.containKey=contain key ''{0}'' + +io.skelp.verifier.type.StringVerifier.alpha=contain only letters +io.skelp.verifier.type.StringVerifier.alphaSpace=contain only letters or space +io.skelp.verifier.type.StringVerifier.alphanumeric=contain only letters or digits +io.skelp.verifier.type.StringVerifier.alphanumericSpace=contain only letters or digits or space +io.skelp.verifier.type.StringVerifier.asciiPrintable=contain only ASCII printable characters +io.skelp.verifier.type.StringVerifier.blank=be blank +io.skelp.verifier.type.StringVerifier.contain=contain ''{0}'' +io.skelp.verifier.type.StringVerifier.containAll=contain all {0} +io.skelp.verifier.type.StringVerifier.containAllIgnoreCase=contain all {0} (ignore case) +io.skelp.verifier.type.StringVerifier.containAny=contain any {0} +io.skelp.verifier.type.StringVerifier.containAnyIgnoreCase=contain any {0} (ignore case) +io.skelp.verifier.type.StringVerifier.containIgnoreCase=contain ''{0}'' (ignore case) +io.skelp.verifier.type.StringVerifier.empty=be empty +io.skelp.verifier.type.StringVerifier.endWith=end with ''{0}'' +io.skelp.verifier.type.StringVerifier.endWithAny=end with any {0} +io.skelp.verifier.type.StringVerifier.endWithAnyIgnoreCase=end with any {0} (ignore case) +io.skelp.verifier.type.StringVerifier.endWithIgnoreCase=end with ''{0}'' (ignore case) +io.skelp.verifier.type.StringVerifier.equalToAnyIgnoreCase=be equal to any {0} (ignore case) +io.skelp.verifier.type.StringVerifier.equalToIgnoreCase=be equal to ''{0}'' (ignore case) +io.skelp.verifier.type.StringVerifier.lowerCase=be all lower case +io.skelp.verifier.type.StringVerifier.match=match ''{0}'' +io.skelp.verifier.type.StringVerifier.matchAll=match all {0} +io.skelp.verifier.type.StringVerifier.matchAny=match any {0} +io.skelp.verifier.type.StringVerifier.numeric=contain only digits +io.skelp.verifier.type.StringVerifier.numericSpace=contain only digits or space +io.skelp.verifier.type.StringVerifier.sizeOf=have a size of ''{0,number,integer}'' +io.skelp.verifier.type.StringVerifier.startWith=start with ''{0}'' +io.skelp.verifier.type.StringVerifier.startWithAny=start with any {0} +io.skelp.verifier.type.StringVerifier.startWithAnyIgnoreCase=start with any {0} (ignore case) +io.skelp.verifier.type.StringVerifier.startWithIgnoreCase=start with ''{0}'' (ignore case) +io.skelp.verifier.type.StringVerifier.upperCase=be all upper case + +io.skelp.verifier.type.ThrowableVerifier.causedBy=have been caused by ''{0}'' +io.skelp.verifier.type.ThrowableVerifier.causedByAll=have been caused by all {0} +io.skelp.verifier.type.ThrowableVerifier.causedByAny=have been caused by any {0} +io.skelp.verifier.type.ThrowableVerifier.checked=be checked +io.skelp.verifier.type.ThrowableVerifier.message=have message ''{0}'' +io.skelp.verifier.type.ThrowableVerifier.unchecked=be unchecked \ No newline at end of file From a2e87a0040b72633438ceb54645768cea24c7635 Mon Sep 17 00:00:00 2001 From: Alasdair Mercer Date: Tue, 3 Oct 2017 00:34:39 +0100 Subject: [PATCH 3/6] New translations Verifier.properties (German) --- src/main/resources/Verifier_de_DE.properties | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/src/main/resources/Verifier_de_DE.properties b/src/main/resources/Verifier_de_DE.properties index 4792c53..0ee1b97 100644 --- a/src/main/resources/Verifier_de_DE.properties +++ b/src/main/resources/Verifier_de_DE.properties @@ -150,4 +150,5 @@ io.skelp.verifier.type.ThrowableVerifier.causedByAll=have been caused by all {0} io.skelp.verifier.type.ThrowableVerifier.causedByAny=have been caused by any {0} io.skelp.verifier.type.ThrowableVerifier.checked=be checked io.skelp.verifier.type.ThrowableVerifier.message=have message ''{0}'' -io.skelp.verifier.type.ThrowableVerifier.unchecked=be unchecked \ No newline at end of file +io.skelp.verifier.type.ThrowableVerifier.unchecked=be unchecked + From c6d418291463948d1243950207d620fd4acea7ac Mon Sep 17 00:00:00 2001 From: Alasdair Mercer Date: Tue, 3 Oct 2017 00:34:40 +0100 Subject: [PATCH 4/6] New translations Verifier.properties (French) --- src/main/resources/Verifier_fr_FR.properties | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/src/main/resources/Verifier_fr_FR.properties b/src/main/resources/Verifier_fr_FR.properties index 4792c53..0ee1b97 100644 --- a/src/main/resources/Verifier_fr_FR.properties +++ b/src/main/resources/Verifier_fr_FR.properties @@ -150,4 +150,5 @@ io.skelp.verifier.type.ThrowableVerifier.causedByAll=have been caused by all {0} io.skelp.verifier.type.ThrowableVerifier.causedByAny=have been caused by any {0} io.skelp.verifier.type.ThrowableVerifier.checked=be checked io.skelp.verifier.type.ThrowableVerifier.message=have message ''{0}'' -io.skelp.verifier.type.ThrowableVerifier.unchecked=be unchecked \ No newline at end of file +io.skelp.verifier.type.ThrowableVerifier.unchecked=be unchecked + From b1886921c1b9a3367770ec49f24b426ef9bdd2ca Mon Sep 17 00:00:00 2001 From: Alasdair Mercer Date: Tue, 3 Oct 2017 09:31:23 +0100 Subject: [PATCH 5/6] New translations Verifier.properties (German) --- src/main/resources/Verifier_de_DE.properties | 240 +++++++++---------- 1 file changed, 120 insertions(+), 120 deletions(-) diff --git a/src/main/resources/Verifier_de_DE.properties b/src/main/resources/Verifier_de_DE.properties index 0ee1b97..2aff03d 100644 --- a/src/main/resources/Verifier_de_DE.properties +++ b/src/main/resources/Verifier_de_DE.properties @@ -1,5 +1,5 @@ #X-Generator: crowdin.com -# Copyright (C) 2017 Alasdair Mercer, Skelp +# Copyright (C) 2017 Alasdair Mercer, !ninja # # Permission is hereby granted, free of charge, to any person obtaining a copy # of this software and associated documentation files (the "Software"), to deal @@ -19,136 +19,136 @@ # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE # SOFTWARE. -io.skelp.verifier.message.ResourceBundleMessageSource.default.message.negated=be invalid -io.skelp.verifier.message.ResourceBundleMessageSource.default.message.normal=be valid -io.skelp.verifier.message.ResourceBundleMessageSource.default.name=Value -io.skelp.verifier.message.ResourceBundleMessageSource.message.negated={0} must not {1}\: {2} -io.skelp.verifier.message.ResourceBundleMessageSource.message.normal={0} must {1}\: {2} +org.notninja.verifier.message.ResourceBundleMessageSource.default.message.negated=be invalid +org.notninja.verifier.message.ResourceBundleMessageSource.default.message.normal=be valid +org.notninja.verifier.message.ResourceBundleMessageSource.default.name=Value +org.notninja.verifier.message.ResourceBundleMessageSource.message.negated={0} must not {1}\: {2} +org.notninja.verifier.message.ResourceBundleMessageSource.message.normal={0} must {1}\: {2} -io.skelp.verifier.AbstractCustomVerifier.equalTo=be equal to ''{0}'' -io.skelp.verifier.AbstractCustomVerifier.equalToAny=be equal to any {0} -io.skelp.verifier.AbstractCustomVerifier.hashedAs=have hash code ''{0,number,integer}'' -io.skelp.verifier.AbstractCustomVerifier.instanceOf=be an instance of ''{0}'' -io.skelp.verifier.AbstractCustomVerifier.instanceOfAll=be an instance of all {0} -io.skelp.verifier.AbstractCustomVerifier.instanceOfAny=be an instance of any {0} -io.skelp.verifier.AbstractCustomVerifier.nulled=be null -io.skelp.verifier.AbstractCustomVerifier.sameAs=be same as ''{0}'' -io.skelp.verifier.AbstractCustomVerifier.sameAsAny=be same as any {0} +org.notninja.verifier.AbstractCustomVerifier.equalTo=be equal to ''{0}'' +org.notninja.verifier.AbstractCustomVerifier.equalToAny=be equal to any {0} +org.notninja.verifier.AbstractCustomVerifier.hashedAs=have hash code ''{0,number,integer}'' +org.notninja.verifier.AbstractCustomVerifier.instanceOf=be an instance of ''{0}'' +org.notninja.verifier.AbstractCustomVerifier.instanceOfAll=be an instance of all {0} +org.notninja.verifier.AbstractCustomVerifier.instanceOfAny=be an instance of any {0} +org.notninja.verifier.AbstractCustomVerifier.nulled=be null +org.notninja.verifier.AbstractCustomVerifier.sameAs=be same as ''{0}'' +org.notninja.verifier.AbstractCustomVerifier.sameAsAny=be same as any {0} -io.skelp.verifier.type.base.BaseCollectionVerifier.contain=contain ''{0}'' -io.skelp.verifier.type.base.BaseCollectionVerifier.containAll=contain all {0} -io.skelp.verifier.type.base.BaseCollectionVerifier.containAny=contain any {0} -io.skelp.verifier.type.base.BaseCollectionVerifier.empty=be empty -io.skelp.verifier.type.base.BaseCollectionVerifier.sizeOf=have a size of ''{0,number,integer}'' +org.notninja.verifier.type.base.BaseCollectionVerifier.contain=contain ''{0}'' +org.notninja.verifier.type.base.BaseCollectionVerifier.containAll=contain all {0} +org.notninja.verifier.type.base.BaseCollectionVerifier.containAny=contain any {0} +org.notninja.verifier.type.base.BaseCollectionVerifier.empty=be empty +org.notninja.verifier.type.base.BaseCollectionVerifier.sizeOf=have a size of ''{0,number,integer}'' -io.skelp.verifier.type.base.BaseComparableVerifier.between=be between ''{0}'' and ''{1}'' (inclusive) -io.skelp.verifier.type.base.BaseComparableVerifier.betweenExclusive=be between ''{0}'' and ''{1}'' (exclusive) -io.skelp.verifier.type.base.BaseComparableVerifier.greaterThan=be greater than ''{0}'' -io.skelp.verifier.type.base.BaseComparableVerifier.greaterThanOrEqualTo=be greater than or equal to ''{0}'' -io.skelp.verifier.type.base.BaseComparableVerifier.lessThan=be less than ''{0}'' -io.skelp.verifier.type.base.BaseComparableVerifier.lessThanOrEqualTo=be less than or equal to ''{0}'' +org.notninja.verifier.type.base.BaseComparableVerifier.between=be between ''{0}'' and ''{1}'' (inclusive) +org.notninja.verifier.type.base.BaseComparableVerifier.betweenExclusive=be between ''{0}'' and ''{1}'' (exclusive) +org.notninja.verifier.type.base.BaseComparableVerifier.greaterThan=be greater than ''{0}'' +org.notninja.verifier.type.base.BaseComparableVerifier.greaterThanOrEqualTo=be greater than or equal to ''{0}'' +org.notninja.verifier.type.base.BaseComparableVerifier.lessThan=be less than ''{0}'' +org.notninja.verifier.type.base.BaseComparableVerifier.lessThanOrEqualTo=be less than or equal to ''{0}'' -io.skelp.verifier.type.base.BaseNumberVerifier.even=be even -io.skelp.verifier.type.base.BaseNumberVerifier.negative=be negative -io.skelp.verifier.type.base.BaseNumberVerifier.odd=be odd -io.skelp.verifier.type.base.BaseNumberVerifier.one=be one -io.skelp.verifier.type.base.BaseNumberVerifier.positive=be positive -io.skelp.verifier.type.base.BaseNumberVerifier.zero=be zero +org.notninja.verifier.type.base.BaseNumberVerifier.even=be even +org.notninja.verifier.type.base.BaseNumberVerifier.negative=be negative +org.notninja.verifier.type.base.BaseNumberVerifier.odd=be odd +org.notninja.verifier.type.base.BaseNumberVerifier.one=be one +org.notninja.verifier.type.base.BaseNumberVerifier.positive=be positive +org.notninja.verifier.type.base.BaseNumberVerifier.zero=be zero -io.skelp.verifier.type.base.BaseSortableCollectionVerifier.sortedBy=be sorted by ''{0}'' +org.notninja.verifier.type.base.BaseSortableCollectionVerifier.sortedBy=be sorted by ''{0}'' -io.skelp.verifier.type.base.BaseTimeVerifier.sameDayAs=be same day as ''{0}'' -io.skelp.verifier.type.base.BaseTimeVerifier.sameEraAs=be same era as ''{0}'' -io.skelp.verifier.type.base.BaseTimeVerifier.sameHourAs=be same hour as ''{0}'' -io.skelp.verifier.type.base.BaseTimeVerifier.sameMinuteAs=be same minute as ''{0}'' -io.skelp.verifier.type.base.BaseTimeVerifier.sameMonthAs=be same month as ''{0}'' -io.skelp.verifier.type.base.BaseTimeVerifier.sameSecondAs=be same second as ''{0}'' -io.skelp.verifier.type.base.BaseTimeVerifier.sameTimeAs=be same time as ''{0}'' -io.skelp.verifier.type.base.BaseTimeVerifier.sameWeekAs=be same week as ''{0}'' -io.skelp.verifier.type.base.BaseTimeVerifier.sameYearAs=be same year as ''{0}'' +org.notninja.verifier.type.base.BaseTimeVerifier.sameDayAs=be same day as ''{0}'' +org.notninja.verifier.type.base.BaseTimeVerifier.sameEraAs=be same era as ''{0}'' +org.notninja.verifier.type.base.BaseTimeVerifier.sameHourAs=be same hour as ''{0}'' +org.notninja.verifier.type.base.BaseTimeVerifier.sameMinuteAs=be same minute as ''{0}'' +org.notninja.verifier.type.base.BaseTimeVerifier.sameMonthAs=be same month as ''{0}'' +org.notninja.verifier.type.base.BaseTimeVerifier.sameSecondAs=be same second as ''{0}'' +org.notninja.verifier.type.base.BaseTimeVerifier.sameTimeAs=be same time as ''{0}'' +org.notninja.verifier.type.base.BaseTimeVerifier.sameWeekAs=be same week as ''{0}'' +org.notninja.verifier.type.base.BaseTimeVerifier.sameYearAs=be same year as ''{0}'' -io.skelp.verifier.type.base.BaseTruthVerifier.falsy=be falsy -io.skelp.verifier.type.base.BaseTruthVerifier.truthy=be truthy +org.notninja.verifier.type.base.BaseTruthVerifier.falsy=be falsy +org.notninja.verifier.type.base.BaseTruthVerifier.truthy=be truthy -io.skelp.verifier.type.CharacterVerifier.alpha=be a letter -io.skelp.verifier.type.CharacterVerifier.alphanumeric=be a letter or digit -io.skelp.verifier.type.CharacterVerifier.ascii=be ASCII -io.skelp.verifier.type.CharacterVerifier.asciiAlpha=be an ASCII letter -io.skelp.verifier.type.CharacterVerifier.asciiAlphaLowerCase=be an ASCII lower case letter -io.skelp.verifier.type.CharacterVerifier.asciiAlphaUpperCase=be an ASCII upper case letter -io.skelp.verifier.type.CharacterVerifier.asciiAlphanumeric=be an ASCII letter or digit -io.skelp.verifier.type.CharacterVerifier.asciiControl=be an ASCII control -io.skelp.verifier.type.CharacterVerifier.asciiNumeric=be an ASCII digit -io.skelp.verifier.type.CharacterVerifier.asciiPrintable=be ASCII printable -io.skelp.verifier.type.CharacterVerifier.lowerCase=be lower case -io.skelp.verifier.type.CharacterVerifier.numeric=be a digit -io.skelp.verifier.type.CharacterVerifier.upperCase=be upper case -io.skelp.verifier.type.CharacterVerifier.whitespace=be whitespace +org.notninja.verifier.type.CharacterVerifier.alpha=be a letter +org.notninja.verifier.type.CharacterVerifier.alphanumeric=be a letter or digit +org.notninja.verifier.type.CharacterVerifier.ascii=be ASCII +org.notninja.verifier.type.CharacterVerifier.asciiAlpha=be an ASCII letter +org.notninja.verifier.type.CharacterVerifier.asciiAlphaLowerCase=be an ASCII lower case letter +org.notninja.verifier.type.CharacterVerifier.asciiAlphaUpperCase=be an ASCII upper case letter +org.notninja.verifier.type.CharacterVerifier.asciiAlphanumeric=be an ASCII letter or digit +org.notninja.verifier.type.CharacterVerifier.asciiControl=be an ASCII control +org.notninja.verifier.type.CharacterVerifier.asciiNumeric=be an ASCII digit +org.notninja.verifier.type.CharacterVerifier.asciiPrintable=be ASCII printable +org.notninja.verifier.type.CharacterVerifier.lowerCase=be lower case +org.notninja.verifier.type.CharacterVerifier.numeric=be a digit +org.notninja.verifier.type.CharacterVerifier.upperCase=be upper case +org.notninja.verifier.type.CharacterVerifier.whitespace=be whitespace -io.skelp.verifier.type.ClassVerifier.annotated=be annotated -io.skelp.verifier.type.ClassVerifier.annotatedWith=be annotated with ''{0}'' -io.skelp.verifier.type.ClassVerifier.annotatedWithAll=be annotated with all {0} -io.skelp.verifier.type.ClassVerifier.annotatedWithAny=be annotated with any {0} -io.skelp.verifier.type.ClassVerifier.annotation=be an annotation -io.skelp.verifier.type.ClassVerifier.anonymous=be anonymous -io.skelp.verifier.type.ClassVerifier.array=be an array -io.skelp.verifier.type.ClassVerifier.assignableFrom=be assignable from ''{0}'' -io.skelp.verifier.type.ClassVerifier.assignableFromAll=be assignable from all {0} -io.skelp.verifier.type.ClassVerifier.assignableFromAny=be assignable from any {0} -io.skelp.verifier.type.ClassVerifier.enumeration=be an enum -io.skelp.verifier.type.ClassVerifier.interfaced=be an interface -io.skelp.verifier.type.ClassVerifier.nested=be nested -io.skelp.verifier.type.ClassVerifier.primitive=be a primitive -io.skelp.verifier.type.ClassVerifier.primitiveOrWrapper=be a primitive or primitive wrapper -io.skelp.verifier.type.ClassVerifier.primitiveWrapper=be a primitive wrapper +org.notninja.verifier.type.ClassVerifier.annotated=be annotated +org.notninja.verifier.type.ClassVerifier.annotatedWith=be annotated with ''{0}'' +org.notninja.verifier.type.ClassVerifier.annotatedWithAll=be annotated with all {0} +org.notninja.verifier.type.ClassVerifier.annotatedWithAny=be annotated with any {0} +org.notninja.verifier.type.ClassVerifier.annotation=be an annotation +org.notninja.verifier.type.ClassVerifier.anonymous=be anonymous +org.notninja.verifier.type.ClassVerifier.array=be an array +org.notninja.verifier.type.ClassVerifier.assignableFrom=be assignable from ''{0}'' +org.notninja.verifier.type.ClassVerifier.assignableFromAll=be assignable from all {0} +org.notninja.verifier.type.ClassVerifier.assignableFromAny=be assignable from any {0} +org.notninja.verifier.type.ClassVerifier.enumeration=be an enum +org.notninja.verifier.type.ClassVerifier.interfaced=be an interface +org.notninja.verifier.type.ClassVerifier.nested=be nested +org.notninja.verifier.type.ClassVerifier.primitive=be a primitive +org.notninja.verifier.type.ClassVerifier.primitiveOrWrapper=be a primitive or primitive wrapper +org.notninja.verifier.type.ClassVerifier.primitiveWrapper=be a primitive wrapper -io.skelp.verifier.type.LocaleVerifier.available=be available -io.skelp.verifier.type.LocaleVerifier.country=be country ''{0}'' -io.skelp.verifier.type.LocaleVerifier.defaulted=be default -io.skelp.verifier.type.LocaleVerifier.language=be language ''{0}'' -io.skelp.verifier.type.LocaleVerifier.script=be script ''{0}'' -io.skelp.verifier.type.LocaleVerifier.variant=be variant ''{0}'' +org.notninja.verifier.type.LocaleVerifier.available=be available +org.notninja.verifier.type.LocaleVerifier.country=be country ''{0}'' +org.notninja.verifier.type.LocaleVerifier.defaulted=be default +org.notninja.verifier.type.LocaleVerifier.language=be language ''{0}'' +org.notninja.verifier.type.LocaleVerifier.script=be script ''{0}'' +org.notninja.verifier.type.LocaleVerifier.variant=be variant ''{0}'' -io.skelp.verifier.type.MapVerifier.containAllKeys=contain all keys {0} -io.skelp.verifier.type.MapVerifier.containAnyKey=contain any key {0} -io.skelp.verifier.type.MapVerifier.containKey=contain key ''{0}'' +org.notninja.verifier.type.MapVerifier.containAllKeys=contain all keys {0} +org.notninja.verifier.type.MapVerifier.containAnyKey=contain any key {0} +org.notninja.verifier.type.MapVerifier.containKey=contain key ''{0}'' -io.skelp.verifier.type.StringVerifier.alpha=contain only letters -io.skelp.verifier.type.StringVerifier.alphaSpace=contain only letters or space -io.skelp.verifier.type.StringVerifier.alphanumeric=contain only letters or digits -io.skelp.verifier.type.StringVerifier.alphanumericSpace=contain only letters or digits or space -io.skelp.verifier.type.StringVerifier.asciiPrintable=contain only ASCII printable characters -io.skelp.verifier.type.StringVerifier.blank=be blank -io.skelp.verifier.type.StringVerifier.contain=contain ''{0}'' -io.skelp.verifier.type.StringVerifier.containAll=contain all {0} -io.skelp.verifier.type.StringVerifier.containAllIgnoreCase=contain all {0} (ignore case) -io.skelp.verifier.type.StringVerifier.containAny=contain any {0} -io.skelp.verifier.type.StringVerifier.containAnyIgnoreCase=contain any {0} (ignore case) -io.skelp.verifier.type.StringVerifier.containIgnoreCase=contain ''{0}'' (ignore case) -io.skelp.verifier.type.StringVerifier.empty=be empty -io.skelp.verifier.type.StringVerifier.endWith=end with ''{0}'' -io.skelp.verifier.type.StringVerifier.endWithAny=end with any {0} -io.skelp.verifier.type.StringVerifier.endWithAnyIgnoreCase=end with any {0} (ignore case) -io.skelp.verifier.type.StringVerifier.endWithIgnoreCase=end with ''{0}'' (ignore case) -io.skelp.verifier.type.StringVerifier.equalToAnyIgnoreCase=be equal to any {0} (ignore case) -io.skelp.verifier.type.StringVerifier.equalToIgnoreCase=be equal to ''{0}'' (ignore case) -io.skelp.verifier.type.StringVerifier.lowerCase=be all lower case -io.skelp.verifier.type.StringVerifier.match=match ''{0}'' -io.skelp.verifier.type.StringVerifier.matchAll=match all {0} -io.skelp.verifier.type.StringVerifier.matchAny=match any {0} -io.skelp.verifier.type.StringVerifier.numeric=contain only digits -io.skelp.verifier.type.StringVerifier.numericSpace=contain only digits or space -io.skelp.verifier.type.StringVerifier.sizeOf=have a size of ''{0,number,integer}'' -io.skelp.verifier.type.StringVerifier.startWith=start with ''{0}'' -io.skelp.verifier.type.StringVerifier.startWithAny=start with any {0} -io.skelp.verifier.type.StringVerifier.startWithAnyIgnoreCase=start with any {0} (ignore case) -io.skelp.verifier.type.StringVerifier.startWithIgnoreCase=start with ''{0}'' (ignore case) -io.skelp.verifier.type.StringVerifier.upperCase=be all upper case +org.notninja.verifier.type.StringVerifier.alpha=contain only letters +org.notninja.verifier.type.StringVerifier.alphaSpace=contain only letters or space +org.notninja.verifier.type.StringVerifier.alphanumeric=contain only letters or digits +org.notninja.verifier.type.StringVerifier.alphanumericSpace=contain only letters or digits or space +org.notninja.verifier.type.StringVerifier.asciiPrintable=contain only ASCII printable characters +org.notninja.verifier.type.StringVerifier.blank=be blank +org.notninja.verifier.type.StringVerifier.contain=contain ''{0}'' +org.notninja.verifier.type.StringVerifier.containAll=contain all {0} +org.notninja.verifier.type.StringVerifier.containAllIgnoreCase=contain all {0} (ignore case) +org.notninja.verifier.type.StringVerifier.containAny=contain any {0} +org.notninja.verifier.type.StringVerifier.containAnyIgnoreCase=contain any {0} (ignore case) +org.notninja.verifier.type.StringVerifier.containIgnoreCase=contain ''{0}'' (ignore case) +org.notninja.verifier.type.StringVerifier.empty=be empty +org.notninja.verifier.type.StringVerifier.endWith=end with ''{0}'' +org.notninja.verifier.type.StringVerifier.endWithAny=end with any {0} +org.notninja.verifier.type.StringVerifier.endWithAnyIgnoreCase=end with any {0} (ignore case) +org.notninja.verifier.type.StringVerifier.endWithIgnoreCase=end with ''{0}'' (ignore case) +org.notninja.verifier.type.StringVerifier.equalToAnyIgnoreCase=be equal to any {0} (ignore case) +org.notninja.verifier.type.StringVerifier.equalToIgnoreCase=be equal to ''{0}'' (ignore case) +org.notninja.verifier.type.StringVerifier.lowerCase=be all lower case +org.notninja.verifier.type.StringVerifier.match=match ''{0}'' +org.notninja.verifier.type.StringVerifier.matchAll=match all {0} +org.notninja.verifier.type.StringVerifier.matchAny=match any {0} +org.notninja.verifier.type.StringVerifier.numeric=contain only digits +org.notninja.verifier.type.StringVerifier.numericSpace=contain only digits or space +org.notninja.verifier.type.StringVerifier.sizeOf=have a size of ''{0,number,integer}'' +org.notninja.verifier.type.StringVerifier.startWith=start with ''{0}'' +org.notninja.verifier.type.StringVerifier.startWithAny=start with any {0} +org.notninja.verifier.type.StringVerifier.startWithAnyIgnoreCase=start with any {0} (ignore case) +org.notninja.verifier.type.StringVerifier.startWithIgnoreCase=start with ''{0}'' (ignore case) +org.notninja.verifier.type.StringVerifier.upperCase=be all upper case -io.skelp.verifier.type.ThrowableVerifier.causedBy=have been caused by ''{0}'' -io.skelp.verifier.type.ThrowableVerifier.causedByAll=have been caused by all {0} -io.skelp.verifier.type.ThrowableVerifier.causedByAny=have been caused by any {0} -io.skelp.verifier.type.ThrowableVerifier.checked=be checked -io.skelp.verifier.type.ThrowableVerifier.message=have message ''{0}'' -io.skelp.verifier.type.ThrowableVerifier.unchecked=be unchecked +org.notninja.verifier.type.ThrowableVerifier.causedBy=have been caused by ''{0}'' +org.notninja.verifier.type.ThrowableVerifier.causedByAll=have been caused by all {0} +org.notninja.verifier.type.ThrowableVerifier.causedByAny=have been caused by any {0} +org.notninja.verifier.type.ThrowableVerifier.checked=be checked +org.notninja.verifier.type.ThrowableVerifier.message=have message ''{0}'' +org.notninja.verifier.type.ThrowableVerifier.unchecked=be unchecked From 2cd41d59ee3882259d2278f432b057c3f7c038fa Mon Sep 17 00:00:00 2001 From: Alasdair Mercer Date: Tue, 3 Oct 2017 09:31:24 +0100 Subject: [PATCH 6/6] New translations Verifier.properties (French) --- src/main/resources/Verifier_fr_FR.properties | 240 +++++++++---------- 1 file changed, 120 insertions(+), 120 deletions(-) diff --git a/src/main/resources/Verifier_fr_FR.properties b/src/main/resources/Verifier_fr_FR.properties index 0ee1b97..2aff03d 100644 --- a/src/main/resources/Verifier_fr_FR.properties +++ b/src/main/resources/Verifier_fr_FR.properties @@ -1,5 +1,5 @@ #X-Generator: crowdin.com -# Copyright (C) 2017 Alasdair Mercer, Skelp +# Copyright (C) 2017 Alasdair Mercer, !ninja # # Permission is hereby granted, free of charge, to any person obtaining a copy # of this software and associated documentation files (the "Software"), to deal @@ -19,136 +19,136 @@ # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE # SOFTWARE. -io.skelp.verifier.message.ResourceBundleMessageSource.default.message.negated=be invalid -io.skelp.verifier.message.ResourceBundleMessageSource.default.message.normal=be valid -io.skelp.verifier.message.ResourceBundleMessageSource.default.name=Value -io.skelp.verifier.message.ResourceBundleMessageSource.message.negated={0} must not {1}\: {2} -io.skelp.verifier.message.ResourceBundleMessageSource.message.normal={0} must {1}\: {2} +org.notninja.verifier.message.ResourceBundleMessageSource.default.message.negated=be invalid +org.notninja.verifier.message.ResourceBundleMessageSource.default.message.normal=be valid +org.notninja.verifier.message.ResourceBundleMessageSource.default.name=Value +org.notninja.verifier.message.ResourceBundleMessageSource.message.negated={0} must not {1}\: {2} +org.notninja.verifier.message.ResourceBundleMessageSource.message.normal={0} must {1}\: {2} -io.skelp.verifier.AbstractCustomVerifier.equalTo=be equal to ''{0}'' -io.skelp.verifier.AbstractCustomVerifier.equalToAny=be equal to any {0} -io.skelp.verifier.AbstractCustomVerifier.hashedAs=have hash code ''{0,number,integer}'' -io.skelp.verifier.AbstractCustomVerifier.instanceOf=be an instance of ''{0}'' -io.skelp.verifier.AbstractCustomVerifier.instanceOfAll=be an instance of all {0} -io.skelp.verifier.AbstractCustomVerifier.instanceOfAny=be an instance of any {0} -io.skelp.verifier.AbstractCustomVerifier.nulled=be null -io.skelp.verifier.AbstractCustomVerifier.sameAs=be same as ''{0}'' -io.skelp.verifier.AbstractCustomVerifier.sameAsAny=be same as any {0} +org.notninja.verifier.AbstractCustomVerifier.equalTo=be equal to ''{0}'' +org.notninja.verifier.AbstractCustomVerifier.equalToAny=be equal to any {0} +org.notninja.verifier.AbstractCustomVerifier.hashedAs=have hash code ''{0,number,integer}'' +org.notninja.verifier.AbstractCustomVerifier.instanceOf=be an instance of ''{0}'' +org.notninja.verifier.AbstractCustomVerifier.instanceOfAll=be an instance of all {0} +org.notninja.verifier.AbstractCustomVerifier.instanceOfAny=be an instance of any {0} +org.notninja.verifier.AbstractCustomVerifier.nulled=be null +org.notninja.verifier.AbstractCustomVerifier.sameAs=be same as ''{0}'' +org.notninja.verifier.AbstractCustomVerifier.sameAsAny=be same as any {0} -io.skelp.verifier.type.base.BaseCollectionVerifier.contain=contain ''{0}'' -io.skelp.verifier.type.base.BaseCollectionVerifier.containAll=contain all {0} -io.skelp.verifier.type.base.BaseCollectionVerifier.containAny=contain any {0} -io.skelp.verifier.type.base.BaseCollectionVerifier.empty=be empty -io.skelp.verifier.type.base.BaseCollectionVerifier.sizeOf=have a size of ''{0,number,integer}'' +org.notninja.verifier.type.base.BaseCollectionVerifier.contain=contain ''{0}'' +org.notninja.verifier.type.base.BaseCollectionVerifier.containAll=contain all {0} +org.notninja.verifier.type.base.BaseCollectionVerifier.containAny=contain any {0} +org.notninja.verifier.type.base.BaseCollectionVerifier.empty=be empty +org.notninja.verifier.type.base.BaseCollectionVerifier.sizeOf=have a size of ''{0,number,integer}'' -io.skelp.verifier.type.base.BaseComparableVerifier.between=be between ''{0}'' and ''{1}'' (inclusive) -io.skelp.verifier.type.base.BaseComparableVerifier.betweenExclusive=be between ''{0}'' and ''{1}'' (exclusive) -io.skelp.verifier.type.base.BaseComparableVerifier.greaterThan=be greater than ''{0}'' -io.skelp.verifier.type.base.BaseComparableVerifier.greaterThanOrEqualTo=be greater than or equal to ''{0}'' -io.skelp.verifier.type.base.BaseComparableVerifier.lessThan=be less than ''{0}'' -io.skelp.verifier.type.base.BaseComparableVerifier.lessThanOrEqualTo=be less than or equal to ''{0}'' +org.notninja.verifier.type.base.BaseComparableVerifier.between=be between ''{0}'' and ''{1}'' (inclusive) +org.notninja.verifier.type.base.BaseComparableVerifier.betweenExclusive=be between ''{0}'' and ''{1}'' (exclusive) +org.notninja.verifier.type.base.BaseComparableVerifier.greaterThan=be greater than ''{0}'' +org.notninja.verifier.type.base.BaseComparableVerifier.greaterThanOrEqualTo=be greater than or equal to ''{0}'' +org.notninja.verifier.type.base.BaseComparableVerifier.lessThan=be less than ''{0}'' +org.notninja.verifier.type.base.BaseComparableVerifier.lessThanOrEqualTo=be less than or equal to ''{0}'' -io.skelp.verifier.type.base.BaseNumberVerifier.even=be even -io.skelp.verifier.type.base.BaseNumberVerifier.negative=be negative -io.skelp.verifier.type.base.BaseNumberVerifier.odd=be odd -io.skelp.verifier.type.base.BaseNumberVerifier.one=be one -io.skelp.verifier.type.base.BaseNumberVerifier.positive=be positive -io.skelp.verifier.type.base.BaseNumberVerifier.zero=be zero +org.notninja.verifier.type.base.BaseNumberVerifier.even=be even +org.notninja.verifier.type.base.BaseNumberVerifier.negative=be negative +org.notninja.verifier.type.base.BaseNumberVerifier.odd=be odd +org.notninja.verifier.type.base.BaseNumberVerifier.one=be one +org.notninja.verifier.type.base.BaseNumberVerifier.positive=be positive +org.notninja.verifier.type.base.BaseNumberVerifier.zero=be zero -io.skelp.verifier.type.base.BaseSortableCollectionVerifier.sortedBy=be sorted by ''{0}'' +org.notninja.verifier.type.base.BaseSortableCollectionVerifier.sortedBy=be sorted by ''{0}'' -io.skelp.verifier.type.base.BaseTimeVerifier.sameDayAs=be same day as ''{0}'' -io.skelp.verifier.type.base.BaseTimeVerifier.sameEraAs=be same era as ''{0}'' -io.skelp.verifier.type.base.BaseTimeVerifier.sameHourAs=be same hour as ''{0}'' -io.skelp.verifier.type.base.BaseTimeVerifier.sameMinuteAs=be same minute as ''{0}'' -io.skelp.verifier.type.base.BaseTimeVerifier.sameMonthAs=be same month as ''{0}'' -io.skelp.verifier.type.base.BaseTimeVerifier.sameSecondAs=be same second as ''{0}'' -io.skelp.verifier.type.base.BaseTimeVerifier.sameTimeAs=be same time as ''{0}'' -io.skelp.verifier.type.base.BaseTimeVerifier.sameWeekAs=be same week as ''{0}'' -io.skelp.verifier.type.base.BaseTimeVerifier.sameYearAs=be same year as ''{0}'' +org.notninja.verifier.type.base.BaseTimeVerifier.sameDayAs=be same day as ''{0}'' +org.notninja.verifier.type.base.BaseTimeVerifier.sameEraAs=be same era as ''{0}'' +org.notninja.verifier.type.base.BaseTimeVerifier.sameHourAs=be same hour as ''{0}'' +org.notninja.verifier.type.base.BaseTimeVerifier.sameMinuteAs=be same minute as ''{0}'' +org.notninja.verifier.type.base.BaseTimeVerifier.sameMonthAs=be same month as ''{0}'' +org.notninja.verifier.type.base.BaseTimeVerifier.sameSecondAs=be same second as ''{0}'' +org.notninja.verifier.type.base.BaseTimeVerifier.sameTimeAs=be same time as ''{0}'' +org.notninja.verifier.type.base.BaseTimeVerifier.sameWeekAs=be same week as ''{0}'' +org.notninja.verifier.type.base.BaseTimeVerifier.sameYearAs=be same year as ''{0}'' -io.skelp.verifier.type.base.BaseTruthVerifier.falsy=be falsy -io.skelp.verifier.type.base.BaseTruthVerifier.truthy=be truthy +org.notninja.verifier.type.base.BaseTruthVerifier.falsy=be falsy +org.notninja.verifier.type.base.BaseTruthVerifier.truthy=be truthy -io.skelp.verifier.type.CharacterVerifier.alpha=be a letter -io.skelp.verifier.type.CharacterVerifier.alphanumeric=be a letter or digit -io.skelp.verifier.type.CharacterVerifier.ascii=be ASCII -io.skelp.verifier.type.CharacterVerifier.asciiAlpha=be an ASCII letter -io.skelp.verifier.type.CharacterVerifier.asciiAlphaLowerCase=be an ASCII lower case letter -io.skelp.verifier.type.CharacterVerifier.asciiAlphaUpperCase=be an ASCII upper case letter -io.skelp.verifier.type.CharacterVerifier.asciiAlphanumeric=be an ASCII letter or digit -io.skelp.verifier.type.CharacterVerifier.asciiControl=be an ASCII control -io.skelp.verifier.type.CharacterVerifier.asciiNumeric=be an ASCII digit -io.skelp.verifier.type.CharacterVerifier.asciiPrintable=be ASCII printable -io.skelp.verifier.type.CharacterVerifier.lowerCase=be lower case -io.skelp.verifier.type.CharacterVerifier.numeric=be a digit -io.skelp.verifier.type.CharacterVerifier.upperCase=be upper case -io.skelp.verifier.type.CharacterVerifier.whitespace=be whitespace +org.notninja.verifier.type.CharacterVerifier.alpha=be a letter +org.notninja.verifier.type.CharacterVerifier.alphanumeric=be a letter or digit +org.notninja.verifier.type.CharacterVerifier.ascii=be ASCII +org.notninja.verifier.type.CharacterVerifier.asciiAlpha=be an ASCII letter +org.notninja.verifier.type.CharacterVerifier.asciiAlphaLowerCase=be an ASCII lower case letter +org.notninja.verifier.type.CharacterVerifier.asciiAlphaUpperCase=be an ASCII upper case letter +org.notninja.verifier.type.CharacterVerifier.asciiAlphanumeric=be an ASCII letter or digit +org.notninja.verifier.type.CharacterVerifier.asciiControl=be an ASCII control +org.notninja.verifier.type.CharacterVerifier.asciiNumeric=be an ASCII digit +org.notninja.verifier.type.CharacterVerifier.asciiPrintable=be ASCII printable +org.notninja.verifier.type.CharacterVerifier.lowerCase=be lower case +org.notninja.verifier.type.CharacterVerifier.numeric=be a digit +org.notninja.verifier.type.CharacterVerifier.upperCase=be upper case +org.notninja.verifier.type.CharacterVerifier.whitespace=be whitespace -io.skelp.verifier.type.ClassVerifier.annotated=be annotated -io.skelp.verifier.type.ClassVerifier.annotatedWith=be annotated with ''{0}'' -io.skelp.verifier.type.ClassVerifier.annotatedWithAll=be annotated with all {0} -io.skelp.verifier.type.ClassVerifier.annotatedWithAny=be annotated with any {0} -io.skelp.verifier.type.ClassVerifier.annotation=be an annotation -io.skelp.verifier.type.ClassVerifier.anonymous=be anonymous -io.skelp.verifier.type.ClassVerifier.array=be an array -io.skelp.verifier.type.ClassVerifier.assignableFrom=be assignable from ''{0}'' -io.skelp.verifier.type.ClassVerifier.assignableFromAll=be assignable from all {0} -io.skelp.verifier.type.ClassVerifier.assignableFromAny=be assignable from any {0} -io.skelp.verifier.type.ClassVerifier.enumeration=be an enum -io.skelp.verifier.type.ClassVerifier.interfaced=be an interface -io.skelp.verifier.type.ClassVerifier.nested=be nested -io.skelp.verifier.type.ClassVerifier.primitive=be a primitive -io.skelp.verifier.type.ClassVerifier.primitiveOrWrapper=be a primitive or primitive wrapper -io.skelp.verifier.type.ClassVerifier.primitiveWrapper=be a primitive wrapper +org.notninja.verifier.type.ClassVerifier.annotated=be annotated +org.notninja.verifier.type.ClassVerifier.annotatedWith=be annotated with ''{0}'' +org.notninja.verifier.type.ClassVerifier.annotatedWithAll=be annotated with all {0} +org.notninja.verifier.type.ClassVerifier.annotatedWithAny=be annotated with any {0} +org.notninja.verifier.type.ClassVerifier.annotation=be an annotation +org.notninja.verifier.type.ClassVerifier.anonymous=be anonymous +org.notninja.verifier.type.ClassVerifier.array=be an array +org.notninja.verifier.type.ClassVerifier.assignableFrom=be assignable from ''{0}'' +org.notninja.verifier.type.ClassVerifier.assignableFromAll=be assignable from all {0} +org.notninja.verifier.type.ClassVerifier.assignableFromAny=be assignable from any {0} +org.notninja.verifier.type.ClassVerifier.enumeration=be an enum +org.notninja.verifier.type.ClassVerifier.interfaced=be an interface +org.notninja.verifier.type.ClassVerifier.nested=be nested +org.notninja.verifier.type.ClassVerifier.primitive=be a primitive +org.notninja.verifier.type.ClassVerifier.primitiveOrWrapper=be a primitive or primitive wrapper +org.notninja.verifier.type.ClassVerifier.primitiveWrapper=be a primitive wrapper -io.skelp.verifier.type.LocaleVerifier.available=be available -io.skelp.verifier.type.LocaleVerifier.country=be country ''{0}'' -io.skelp.verifier.type.LocaleVerifier.defaulted=be default -io.skelp.verifier.type.LocaleVerifier.language=be language ''{0}'' -io.skelp.verifier.type.LocaleVerifier.script=be script ''{0}'' -io.skelp.verifier.type.LocaleVerifier.variant=be variant ''{0}'' +org.notninja.verifier.type.LocaleVerifier.available=be available +org.notninja.verifier.type.LocaleVerifier.country=be country ''{0}'' +org.notninja.verifier.type.LocaleVerifier.defaulted=be default +org.notninja.verifier.type.LocaleVerifier.language=be language ''{0}'' +org.notninja.verifier.type.LocaleVerifier.script=be script ''{0}'' +org.notninja.verifier.type.LocaleVerifier.variant=be variant ''{0}'' -io.skelp.verifier.type.MapVerifier.containAllKeys=contain all keys {0} -io.skelp.verifier.type.MapVerifier.containAnyKey=contain any key {0} -io.skelp.verifier.type.MapVerifier.containKey=contain key ''{0}'' +org.notninja.verifier.type.MapVerifier.containAllKeys=contain all keys {0} +org.notninja.verifier.type.MapVerifier.containAnyKey=contain any key {0} +org.notninja.verifier.type.MapVerifier.containKey=contain key ''{0}'' -io.skelp.verifier.type.StringVerifier.alpha=contain only letters -io.skelp.verifier.type.StringVerifier.alphaSpace=contain only letters or space -io.skelp.verifier.type.StringVerifier.alphanumeric=contain only letters or digits -io.skelp.verifier.type.StringVerifier.alphanumericSpace=contain only letters or digits or space -io.skelp.verifier.type.StringVerifier.asciiPrintable=contain only ASCII printable characters -io.skelp.verifier.type.StringVerifier.blank=be blank -io.skelp.verifier.type.StringVerifier.contain=contain ''{0}'' -io.skelp.verifier.type.StringVerifier.containAll=contain all {0} -io.skelp.verifier.type.StringVerifier.containAllIgnoreCase=contain all {0} (ignore case) -io.skelp.verifier.type.StringVerifier.containAny=contain any {0} -io.skelp.verifier.type.StringVerifier.containAnyIgnoreCase=contain any {0} (ignore case) -io.skelp.verifier.type.StringVerifier.containIgnoreCase=contain ''{0}'' (ignore case) -io.skelp.verifier.type.StringVerifier.empty=be empty -io.skelp.verifier.type.StringVerifier.endWith=end with ''{0}'' -io.skelp.verifier.type.StringVerifier.endWithAny=end with any {0} -io.skelp.verifier.type.StringVerifier.endWithAnyIgnoreCase=end with any {0} (ignore case) -io.skelp.verifier.type.StringVerifier.endWithIgnoreCase=end with ''{0}'' (ignore case) -io.skelp.verifier.type.StringVerifier.equalToAnyIgnoreCase=be equal to any {0} (ignore case) -io.skelp.verifier.type.StringVerifier.equalToIgnoreCase=be equal to ''{0}'' (ignore case) -io.skelp.verifier.type.StringVerifier.lowerCase=be all lower case -io.skelp.verifier.type.StringVerifier.match=match ''{0}'' -io.skelp.verifier.type.StringVerifier.matchAll=match all {0} -io.skelp.verifier.type.StringVerifier.matchAny=match any {0} -io.skelp.verifier.type.StringVerifier.numeric=contain only digits -io.skelp.verifier.type.StringVerifier.numericSpace=contain only digits or space -io.skelp.verifier.type.StringVerifier.sizeOf=have a size of ''{0,number,integer}'' -io.skelp.verifier.type.StringVerifier.startWith=start with ''{0}'' -io.skelp.verifier.type.StringVerifier.startWithAny=start with any {0} -io.skelp.verifier.type.StringVerifier.startWithAnyIgnoreCase=start with any {0} (ignore case) -io.skelp.verifier.type.StringVerifier.startWithIgnoreCase=start with ''{0}'' (ignore case) -io.skelp.verifier.type.StringVerifier.upperCase=be all upper case +org.notninja.verifier.type.StringVerifier.alpha=contain only letters +org.notninja.verifier.type.StringVerifier.alphaSpace=contain only letters or space +org.notninja.verifier.type.StringVerifier.alphanumeric=contain only letters or digits +org.notninja.verifier.type.StringVerifier.alphanumericSpace=contain only letters or digits or space +org.notninja.verifier.type.StringVerifier.asciiPrintable=contain only ASCII printable characters +org.notninja.verifier.type.StringVerifier.blank=be blank +org.notninja.verifier.type.StringVerifier.contain=contain ''{0}'' +org.notninja.verifier.type.StringVerifier.containAll=contain all {0} +org.notninja.verifier.type.StringVerifier.containAllIgnoreCase=contain all {0} (ignore case) +org.notninja.verifier.type.StringVerifier.containAny=contain any {0} +org.notninja.verifier.type.StringVerifier.containAnyIgnoreCase=contain any {0} (ignore case) +org.notninja.verifier.type.StringVerifier.containIgnoreCase=contain ''{0}'' (ignore case) +org.notninja.verifier.type.StringVerifier.empty=be empty +org.notninja.verifier.type.StringVerifier.endWith=end with ''{0}'' +org.notninja.verifier.type.StringVerifier.endWithAny=end with any {0} +org.notninja.verifier.type.StringVerifier.endWithAnyIgnoreCase=end with any {0} (ignore case) +org.notninja.verifier.type.StringVerifier.endWithIgnoreCase=end with ''{0}'' (ignore case) +org.notninja.verifier.type.StringVerifier.equalToAnyIgnoreCase=be equal to any {0} (ignore case) +org.notninja.verifier.type.StringVerifier.equalToIgnoreCase=be equal to ''{0}'' (ignore case) +org.notninja.verifier.type.StringVerifier.lowerCase=be all lower case +org.notninja.verifier.type.StringVerifier.match=match ''{0}'' +org.notninja.verifier.type.StringVerifier.matchAll=match all {0} +org.notninja.verifier.type.StringVerifier.matchAny=match any {0} +org.notninja.verifier.type.StringVerifier.numeric=contain only digits +org.notninja.verifier.type.StringVerifier.numericSpace=contain only digits or space +org.notninja.verifier.type.StringVerifier.sizeOf=have a size of ''{0,number,integer}'' +org.notninja.verifier.type.StringVerifier.startWith=start with ''{0}'' +org.notninja.verifier.type.StringVerifier.startWithAny=start with any {0} +org.notninja.verifier.type.StringVerifier.startWithAnyIgnoreCase=start with any {0} (ignore case) +org.notninja.verifier.type.StringVerifier.startWithIgnoreCase=start with ''{0}'' (ignore case) +org.notninja.verifier.type.StringVerifier.upperCase=be all upper case -io.skelp.verifier.type.ThrowableVerifier.causedBy=have been caused by ''{0}'' -io.skelp.verifier.type.ThrowableVerifier.causedByAll=have been caused by all {0} -io.skelp.verifier.type.ThrowableVerifier.causedByAny=have been caused by any {0} -io.skelp.verifier.type.ThrowableVerifier.checked=be checked -io.skelp.verifier.type.ThrowableVerifier.message=have message ''{0}'' -io.skelp.verifier.type.ThrowableVerifier.unchecked=be unchecked +org.notninja.verifier.type.ThrowableVerifier.causedBy=have been caused by ''{0}'' +org.notninja.verifier.type.ThrowableVerifier.causedByAll=have been caused by all {0} +org.notninja.verifier.type.ThrowableVerifier.causedByAny=have been caused by any {0} +org.notninja.verifier.type.ThrowableVerifier.checked=be checked +org.notninja.verifier.type.ThrowableVerifier.message=have message ''{0}'' +org.notninja.verifier.type.ThrowableVerifier.unchecked=be unchecked