From 36a112c2c195a69c25742a846f687599168c2d63 Mon Sep 17 00:00:00 2001 From: Onur Cinar Date: Fri, 27 Dec 2024 07:00:53 -0800 Subject: [PATCH] Add upper and lower normalizers and tests to v2. (#146) # Describe Request Add upper and lower normalizers and tests to v2. # Change Type New code. --- v2/lower.go | 32 ++++++++++++++++++++++++++++++++ v2/lower_test.go | 47 +++++++++++++++++++++++++++++++++++++++++++++++ v2/maker.go | 4 +++- v2/upper.go | 32 ++++++++++++++++++++++++++++++++ v2/upper_test.go | 47 +++++++++++++++++++++++++++++++++++++++++++++++ 5 files changed, 161 insertions(+), 1 deletion(-) create mode 100644 v2/lower.go create mode 100644 v2/lower_test.go create mode 100644 v2/upper.go create mode 100644 v2/upper_test.go diff --git a/v2/lower.go b/v2/lower.go new file mode 100644 index 0000000..803ca99 --- /dev/null +++ b/v2/lower.go @@ -0,0 +1,32 @@ +// Copyright (c) 2023-2024 Onur Cinar. +// Use of this source code is governed by a MIT-style +// license that can be found in the LICENSE file. +// https://github.com/cinar/checker + +package v2 + +import ( + "reflect" + "strings" +) + +const ( + // nameLower is the name of the lower normalizer. + nameLower = "lower" +) + +// Lower maps all Unicode letters in the given value to their lower case. +func Lower(value string) (string, error) { + return strings.ToLower(value), nil +} + +// reflectLower maps all Unicode letters in the given value to their lower case. +func reflectLower(value reflect.Value) (reflect.Value, error) { + newValue, err := Lower(value.Interface().(string)) + return reflect.ValueOf(newValue), err +} + +// makeLower returns the lower normalizer function. +func makeLower(_ string) CheckFunc[reflect.Value] { + return reflectLower +} diff --git a/v2/lower_test.go b/v2/lower_test.go new file mode 100644 index 0000000..491e671 --- /dev/null +++ b/v2/lower_test.go @@ -0,0 +1,47 @@ +// Copyright (c) 2023-2024 Onur Cinar. +// Use of this source code is governed by a MIT-style +// license that can be found in the LICENSE file. +// https://github.com/cinar/checker + +package v2_test + +import ( + "testing" + + v2 "github.com/cinar/checker/v2" +) + +func TestLower(t *testing.T) { + input := "CHECKER" + expected := "checker" + + actual, err := v2.Lower(input) + if err != nil { + t.Fatal(err) + } + + if actual != expected { + t.Fatalf("actual %s expected %s", actual, expected) + } +} + +func TestReflectLower(t *testing.T) { + type Person struct { + Name string `checkers:"lower"` + } + + person := &Person{ + Name: "CHECKER", + } + + expected := "checker" + + errs, ok := v2.CheckStruct(person) + if !ok { + t.Fatalf("got unexpected errors %v", errs) + } + + if person.Name != expected { + t.Fatalf("actual %s expected %s", person.Name, expected) + } +} diff --git a/v2/maker.go b/v2/maker.go index e65bcb3..24b26e9 100644 --- a/v2/maker.go +++ b/v2/maker.go @@ -22,13 +22,14 @@ var makers = map[string]MakeCheckFunc{ nameCreditCard: makeCreditCard, nameDigits: makeDigits, nameEmail: makeEmail, + nameFQDN: makeFQDN, nameHTMLEscape: makeHTMLEscape, nameHTMLUnescape: makeHTMLUnescape, - nameFQDN: makeFQDN, nameIP: makeIP, nameIPv4: makeIPv4, nameIPv6: makeIPv6, nameISBN: makeISBN, + nameLower: makeLower, nameLUHN: makeLUHN, nameMAC: makeMAC, nameMaxLen: makeMaxLen, @@ -37,6 +38,7 @@ var makers = map[string]MakeCheckFunc{ nameTrimLeft: makeTrimLeft, nameTrimRight: makeTrimRight, nameTrimSpace: makeTrimSpace, + nameUpper: makeUpper, nameURL: makeURL, nameURLEscape: makeURLEscape, nameURLUnescape: makeURLUnescape, diff --git a/v2/upper.go b/v2/upper.go new file mode 100644 index 0000000..cd8ea86 --- /dev/null +++ b/v2/upper.go @@ -0,0 +1,32 @@ +// Copyright (c) 2023-2024 Onur Cinar. +// Use of this source code is governed by a MIT-style +// license that can be found in the LICENSE file. +// https://github.com/cinar/checker + +package v2 + +import ( + "reflect" + "strings" +) + +const ( + // nameUpper is the name of the upper normalizer. + nameUpper = "upper" +) + +// Upper maps all Unicode letters in the given value to their upper case. +func Upper(value string) (string, error) { + return strings.ToUpper(value), nil +} + +// reflectUpper maps all Unicode letters in the given value to their upper case. +func reflectUpper(value reflect.Value) (reflect.Value, error) { + newValue, err := Upper(value.Interface().(string)) + return reflect.ValueOf(newValue), err +} + +// makeUpper returns the upper normalizer function. +func makeUpper(_ string) CheckFunc[reflect.Value] { + return reflectUpper +} diff --git a/v2/upper_test.go b/v2/upper_test.go new file mode 100644 index 0000000..d7fa127 --- /dev/null +++ b/v2/upper_test.go @@ -0,0 +1,47 @@ +// Copyright (c) 2023-2024 Onur Cinar. +// Use of this source code is governed by a MIT-style +// license that can be found in the LICENSE file. +// https://github.com/cinar/checker + +package v2_test + +import ( + "testing" + + v2 "github.com/cinar/checker/v2" +) + +func TestUpper(t *testing.T) { + input := "checker" + expected := "CHECKER" + + actual, err := v2.Upper(input) + if err != nil { + t.Fatal(err) + } + + if actual != expected { + t.Fatalf("actual %s expected %s", actual, expected) + } +} + +func TestReflectUpper(t *testing.T) { + type Person struct { + Name string `checkers:"upper"` + } + + person := &Person{ + Name: "checker", + } + + expected := "CHECKER" + + errs, ok := v2.CheckStruct(person) + if !ok { + t.Fatalf("got unexpected errors %v", errs) + } + + if person.Name != expected { + t.Fatalf("actual %s expected %s", person.Name, expected) + } +}