it.Matches - Code Metrics - Inspection of "regex_constraint" - muonsoft/validation - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Pull Request — main (#25)

by Rushan

created 2021-03-17 16:52 UTC

it.Matches A

↳ Parent: it/string.go

Complexity

Conditions

Size

Total Lines	5
Code Lines	5

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	1
CRAP Score	1

Importance

Changes

Metric	Value
cc	1
eloc	5
dl	0
loc	5
ccs	1
cts	1
cp	1
crap	1
rs	10
c	0
b	0
f	0
nop	1

package it

import (
	"github.com/muonsoft/validation"
	"github.com/muonsoft/validation/code"
	"github.com/muonsoft/validation/message"

	"regexp"
	"strconv"
	"unicode/utf8"
)

// LengthConstraint checks that a given string length is between some minimum and maximum value.
type LengthConstraint struct {
	isIgnored            bool
	checkMin             bool
	checkMax             bool
	min                  int
	max                  int
	minMessageTemplate   string
	maxMessageTemplate   string
	exactMessageTemplate string
}

func newLengthConstraint(min int, max int, checkMin bool, checkMax bool) LengthConstraint {
	return LengthConstraint{
		min:                  min,
		max:                  max,
		checkMin:             checkMin,
		checkMax:             checkMax,
		minMessageTemplate:   message.LengthTooFew,
		maxMessageTemplate:   message.LengthTooMany,
		exactMessageTemplate: message.LengthExact,
	}
}

func HasMinLength(min int) LengthConstraint {
	return newLengthConstraint(min, 0, true, false)
}

func HasMaxLength(max int) LengthConstraint {
	return newLengthConstraint(0, max, false, true)
}

func HasLengthBetween(min int, max int) LengthConstraint {
	return newLengthConstraint(min, max, true, true)
}

func HasExactLength(count int) LengthConstraint {
	return newLengthConstraint(count, count, true, true)
}

func (c LengthConstraint) SetUp() error {
	return nil
}

func (c LengthConstraint) Name() string {
	return "LengthConstraint"
}

func (c LengthConstraint) When(condition bool) LengthConstraint {
	c.isIgnored = !condition
	return c
}

func (c LengthConstraint) MinMessage(message string) LengthConstraint {
	c.minMessageTemplate = message
	return c
}

func (c LengthConstraint) MaxMessage(message string) LengthConstraint {
	c.maxMessageTemplate = message
	return c
}

func (c LengthConstraint) ExactMessage(message string) LengthConstraint {
	c.exactMessageTemplate = message
	return c
}

func (c LengthConstraint) ValidateString(value *string, scope validation.Scope) error {
	if c.isIgnored || value == nil || *value == "" {
		return nil
	}

	count := utf8.RuneCountInString(*value)

	if c.checkMax && count > c.max {
		return c.newViolation(count, c.max, code.LengthTooMany, c.maxMessageTemplate, scope)
	}
	if c.checkMin && count < c.min {
		return c.newViolation(count, c.min, code.LengthTooFew, c.minMessageTemplate, scope)
	}

	return nil
}

func (c LengthConstraint) newViolation(
	count, limit int,
	violationCode, message string,
	scope validation.Scope,
) validation.Violation {
	if c.checkMin && c.checkMax && c.min == c.max {
		message = c.exactMessageTemplate
		violationCode = code.LengthExact
	}

	return scope.BuildViolation(violationCode, message).
		SetPluralCount(limit).
		SetParameters(map[string]string{
			"{{ count }}": strconv.Itoa(count),
			"{{ limit }}": strconv.Itoa(limit),
		}).
		CreateViolation()
}

// RegexConstraint is used to ensure that the given value corresponds to regex pattern.
type RegexConstraint struct {
	isIgnored       bool
	match           bool
	messageTemplate string
	regex           *regexp.Regexp
}

// Matches creates a RegexConstraint for checking whether a value match.
//
// Example
//	err := validator.ValidateString(&s, it.Matches(regexp.MustCompile("^[a-z]+$")))
func Matches(regex *regexp.Regexp) RegexConstraint {
	return RegexConstraint{
		regex:           regex,
		match:           true,
		messageTemplate: message.NotValid,
	}
}

// Matches creates a RegexConstraint for checking whether a value not match.
//
// Example
//	err := validator.ValidateString(&s, it.DoesNotMatch(regexp.MustCompile("^[a-z]+$")))
func DoesNotMatch(regex *regexp.Regexp) RegexConstraint {
	return RegexConstraint{
		regex:           regex,
		match:           false,
		messageTemplate: message.NotValid,
	}
}

// SetUp will return an error if the pattern is empty.
func (c RegexConstraint) SetUp() error {
	if c.regex == nil {
		return errEmptyRegex
	}

	return nil
}

// Name is the constraint name.
func (c RegexConstraint) Name() string {
	return "RegexConstraint"
}

// Message sets the violation message template. You can use template parameters.
// for injecting its values into the final message:
//
//	{{ value }} - the current (invalid) value.
func (c RegexConstraint) Message(message string) RegexConstraint {
	c.messageTemplate = message
	return c
}

// When enables conditional validation of this constraint. If the expression evaluates to false,
// then the constraint will be ignored.
func (c RegexConstraint) When(condition bool) RegexConstraint {
	c.isIgnored = !condition
	return c
}

func (c RegexConstraint) ValidateString(value *string, scope validation.Scope) error {
	if c.isIgnored || value == nil || *value == "" {
		return nil
	}

	if !(c.match != c.regex.MatchString(*value)) {
		return nil
	}

	return scope.
		BuildViolation(code.MatchingFailed, c.messageTemplate).
		SetParameter("{{ value }}", *value).
		CreateViolation()
}


1		package it
2
3		import (
4		"github.com/muonsoft/validation"
5		"github.com/muonsoft/validation/code"
6		"github.com/muonsoft/validation/message"
7
8		"regexp"
9		"strconv"
10		"unicode/utf8"
11		)
12
13		// LengthConstraint checks that a given string length is between some minimum and maximum value.
14		type LengthConstraint struct {
15		isIgnored bool
16		checkMin bool
17		checkMax bool
18		min int
19		max int
20		minMessageTemplate string
21		maxMessageTemplate string
22		exactMessageTemplate string
23		}
24
25		func newLengthConstraint(min int, max int, checkMin bool, checkMax bool) LengthConstraint {
26	1	return LengthConstraint{
27		min: min,
28		max: max,
29		checkMin: checkMin,
30		checkMax: checkMax,
31		minMessageTemplate: message.LengthTooFew,
32		maxMessageTemplate: message.LengthTooMany,
33		exactMessageTemplate: message.LengthExact,
34		}
35		}
36
37		func HasMinLength(min int) LengthConstraint {
38	1	return newLengthConstraint(min, 0, true, false)
39		}
40
41		func HasMaxLength(max int) LengthConstraint {
42	1	return newLengthConstraint(0, max, false, true)
43		}
44
45		func HasLengthBetween(min int, max int) LengthConstraint {
46	1	return newLengthConstraint(min, max, true, true)
47		}
48
49		func HasExactLength(count int) LengthConstraint {
50	1	return newLengthConstraint(count, count, true, true)
51		}
52
53		func (c LengthConstraint) SetUp() error {
54	1	return nil
55		}
56
57		func (c LengthConstraint) Name() string {
58		return "LengthConstraint"
59		}
60
61		func (c LengthConstraint) When(condition bool) LengthConstraint {
62	1	c.isIgnored = !condition
63	1	return c
64		}
65
66		func (c LengthConstraint) MinMessage(message string) LengthConstraint {
67	1	c.minMessageTemplate = message
68	1	return c
69		}
70
71		func (c LengthConstraint) MaxMessage(message string) LengthConstraint {
72	1	c.maxMessageTemplate = message
73	1	return c
74		}
75
76		func (c LengthConstraint) ExactMessage(message string) LengthConstraint {
77	1	c.exactMessageTemplate = message
78	1	return c
79		}
80
81		func (c LengthConstraint) ValidateString(value *string, scope validation.Scope) error {
82	1	if c.isIgnored \|\| value == nil \|\| *value == "" {
83	1	return nil
84		}
85
86	1	count := utf8.RuneCountInString(*value)
87
88	1	if c.checkMax && count > c.max {
89	1	return c.newViolation(count, c.max, code.LengthTooMany, c.maxMessageTemplate, scope)
90		}
91	1	if c.checkMin && count < c.min {
92	1	return c.newViolation(count, c.min, code.LengthTooFew, c.minMessageTemplate, scope)
93		}
94
95	1	return nil
96		}
97
98		func (c LengthConstraint) newViolation(
99		count, limit int,
100		violationCode, message string,
101		scope validation.Scope,
102		) validation.Violation {
103	1	if c.checkMin && c.checkMax && c.min == c.max {
104	1	message = c.exactMessageTemplate
105	1	violationCode = code.LengthExact
106		}
107
108	1	return scope.BuildViolation(violationCode, message).
109		SetPluralCount(limit).
110		SetParameters(map[string]string{
111		"{{ count }}": strconv.Itoa(count),
112		"{{ limit }}": strconv.Itoa(limit),
113		}).
114		CreateViolation()
115		}
116
117		// RegexConstraint is used to ensure that the given value corresponds to regex pattern.
118		type RegexConstraint struct {
119		isIgnored bool
120		match bool
121		messageTemplate string
122		regex *regexp.Regexp
123		}
124
125		// Matches creates a RegexConstraint for checking whether a value match.
126		//
127		// Example
128		// err := validator.ValidateString(&s, it.Matches(regexp.MustCompile("^[a-z]+$")))
129		func Matches(regex *regexp.Regexp) RegexConstraint {
130	1	return RegexConstraint{
131		regex: regex,
132		match: true,
133		messageTemplate: message.NotValid,
134		}
135		}
136
137		// Matches creates a RegexConstraint for checking whether a value not match.
138		//
139		// Example
140		// err := validator.ValidateString(&s, it.DoesNotMatch(regexp.MustCompile("^[a-z]+$")))
141		func DoesNotMatch(regex *regexp.Regexp) RegexConstraint {
142	1	return RegexConstraint{
143		regex: regex,
144		match: false,
145		messageTemplate: message.NotValid,
146		}
147		}
148
149		// SetUp will return an error if the pattern is empty.
150		func (c RegexConstraint) SetUp() error {
151	1	if c.regex == nil {
152	1	return errEmptyRegex
153		}
154
155	1	return nil
156		}
157
158		// Name is the constraint name.
159		func (c RegexConstraint) Name() string {
160	1	return "RegexConstraint"
161		}
162
163		// Message sets the violation message template. You can use template parameters.
164		// for injecting its values into the final message:
165		//
166		// {{ value }} - the current (invalid) value.
167		func (c RegexConstraint) Message(message string) RegexConstraint {
168	1	c.messageTemplate = message
169	1	return c
170		}
171
172		// When enables conditional validation of this constraint. If the expression evaluates to false,
173		// then the constraint will be ignored.
174		func (c RegexConstraint) When(condition bool) RegexConstraint {
175	1	c.isIgnored = !condition
176	1	return c
177		}
178
179		func (c RegexConstraint) ValidateString(value *string, scope validation.Scope) error {
180	1	if c.isIgnored \|\| value == nil \|\| *value == "" {
181	1	return nil
182		}
183
184	1	if !(c.match != c.regex.MatchString(*value)) {
185	1	return nil
186		}
187
188	1	return scope.
189		BuildViolation(code.MatchingFailed, c.messageTemplate).
190		SetParameter("{{ value }}", *value).
191		CreateViolation()
192		}
193

muonsoft / validation

Pull Request — main (#25)

it.Matches A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like