it.URLConstraint.WithSchemas - Code Metrics - Inspection of "Merge pull request #68 from muonsoft/validation-gr..." - muonsoft/validation - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — main ( 957b58...866640 )

by Igor

created 2022-01-27 17:53 UTC

it.URLConstraint.WithSchemas A

↳ Parent: it/web.go

Complexity

Conditions

Size

Total Lines	3
Code Lines	3

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	2
CRAP Score	1

Importance

Changes

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

package it

import (
	"errors"
	"net"

	"github.com/muonsoft/validation"
	"github.com/muonsoft/validation/code"
	"github.com/muonsoft/validation/is"
	"github.com/muonsoft/validation/message"
	"github.com/muonsoft/validation/validate"
)

// IsEmail is used for simplified validation of an email address. It allows all values
// with an "@" symbol in, and a "." in the second host part of the email address.
func IsEmail() validation.CustomStringConstraint {
	return validation.NewCustomStringConstraint(
		is.Email,
		"EmailConstraint",
		code.InvalidEmail,
		message.Templates[code.InvalidEmail],
	)
}

// IsHTML5Email is used for validation of an email address based on pattern for HTML5
// (see https://html.spec.whatwg.org/multipage/input.html#valid-e-mail-address).
func IsHTML5Email() validation.CustomStringConstraint {
	return validation.NewCustomStringConstraint(
		is.HTML5Email,
		"HTML5EmailConstraint",
		code.InvalidEmail,
		message.Templates[code.InvalidEmail],
	)
}

// IsHostname validates that a value is a valid hostname. It checks that:
//	• each label within a valid hostname may be no more than 63 octets long;
//	• the total length of the hostname must not exceed 255 characters;
//	• hostname is fully qualified and include its top-level domain name
//	  (for instance, example.com is valid but example is not);
//	• checks for reserved top-level domains according to RFC 2606
//	  (hostnames containing them are not considered valid:
//	  .example, .invalid, .localhost, and .test).
//
// If you do not want to check for top-level domains use IsLooseHostname version of constraint.
func IsHostname() validation.CustomStringConstraint {
	return validation.NewCustomStringConstraint(
		is.StrictHostname,
		"HostnameConstraint",
		code.InvalidHostname,
		message.Templates[code.InvalidHostname],
	)
}

// IsLooseHostname validates that a value is a valid hostname. It checks that:
//	• each label within a valid hostname may be no more than 63 octets long;
//	• the total length of the hostname must not exceed 255 characters.
func IsLooseHostname() validation.CustomStringConstraint {
	return validation.NewCustomStringConstraint(
		is.Hostname,
		"LooseHostnameConstraint",
		code.InvalidHostname,
		message.Templates[code.InvalidHostname],
	)
}

// URLConstraint is used to validate URL string. This constraint doesn’t check that the host of the
// given URL really exists, because the information of the DNS records is not reliable.
//
// This constraint doesn't check the length of the URL. Use LengthConstraint to check the length of the given value.
type URLConstraint struct {
	isIgnored              bool
	supportsRelativeSchema bool
	schemas                []string
	groups                 []string
	code                   string
	messageTemplate        string
	messageParameters      validation.TemplateParameterList
}

// IsURL creates a URLConstraint to validate an URL. By default, constraint checks
// only for the http:// and https:// schemas. Use the WithSchemas method to configure
// the list of expected schemas. Also, you can use WithRelativeSchema to enable support
// of the relative schema (without schema, e.g. "//example.com").
func IsURL() URLConstraint {
	return URLConstraint{
		schemas:         []string{"http", "https"},
		code:            code.InvalidURL,
		messageTemplate: message.Templates[code.InvalidURL],
	}
}

// SetUp will return an error if the list of schemas is empty.
func (c URLConstraint) SetUp() error {
	if len(c.schemas) == 0 {
		return errEmptySchemas
	}

	return nil
}

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

// WithRelativeSchema enables support of relative URL schema, which means that URL value
// may be treated as relative (without schema, e.g. "//example.com").
func (c URLConstraint) WithRelativeSchema() URLConstraint {
	c.supportsRelativeSchema = true
	return c
}

// WithSchemas is used to set up a list of accepted schemas. For example, if you also consider the ftp:// type URLs
// to be valid, redefine the schemas list, listing http, https, and also ftp.
// If the list is empty, then an error will be returned by the SetUp method.
func (c URLConstraint) WithSchemas(schemas ...string) URLConstraint {
	c.schemas = schemas
	return c
}

// Code overrides default code for produced violation.
func (c URLConstraint) Code(code string) URLConstraint {
	c.code = code
	return c
}

// Message sets the violation message template. You can set custom template parameters
// for injecting its values into the final message. Also, you can use default parameters:
//
//	{{ value }} - the current (invalid) value.
func (c URLConstraint) Message(template string, parameters ...validation.TemplateParameter) URLConstraint {
	c.messageTemplate = template
	c.messageParameters = parameters
	return c
}

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

// WhenGroups enables conditional validation of the constraint by using the validation groups.
func (c URLConstraint) WhenGroups(groups ...string) URLConstraint {
	c.groups = groups
	return c
}

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

	schemas := c.schemas
	if c.supportsRelativeSchema {
		schemas = append(schemas, "")
	}
	if is.URL(*value, schemas...) {
		return nil
	}

	return scope.BuildViolation(c.code, c.messageTemplate).
		SetParameters(
			c.messageParameters.Prepend(
				validation.TemplateParameter{Key: "{{ value }}", Value: *value},
			)...,
		).
		CreateViolation()
}

// IPConstraint is used to validate IP address. You can check for different versions
// and restrict some ranges by additional options.
type IPConstraint struct {
	isIgnored    bool
	validate     func(value string, restrictions ...validate.IPRestriction) error
	restrictions []validate.IPRestriction

	groups []string

	invalidCode    string
	prohibitedCode string

	invalidMessageTemplate      string
	invalidMessageParameters    validation.TemplateParameterList
	prohibitedMessageTemplate   string
	prohibitedMessageParameters validation.TemplateParameterList
}

// IsIP creates an IPConstraint to validate an IP address (IPv4 or IPv6).
func IsIP() IPConstraint {
	return newIPConstraint(validate.IP)
}

// IsIPv4 creates an IPConstraint to validate an IPv4 address.
func IsIPv4() IPConstraint {
	return newIPConstraint(validate.IPv4)
}

// IsIPv6 creates an IPConstraint to validate an IPv4 address.
func IsIPv6() IPConstraint {
	return newIPConstraint(validate.IPv6)
}

func newIPConstraint(validate func(value string, restrictions ...validate.IPRestriction) error) IPConstraint {
	return IPConstraint{
		validate:                  validate,
		invalidCode:               code.InvalidIP,
		prohibitedCode:            code.ProhibitedIP,
		invalidMessageTemplate:    message.Templates[code.InvalidIP],
		prohibitedMessageTemplate: message.Templates[code.ProhibitedIP],
	}
}

// SetUp always returns no error.
func (c IPConstraint) SetUp() error {
	return nil
}

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

// DenyPrivateIP denies using of private IPs according to RFC 1918 (IPv4 addresses)
// and RFC 4193 (IPv6 addresses).
func (c IPConstraint) DenyPrivateIP() IPConstraint {
	c.restrictions = append(c.restrictions, validate.DenyPrivateIP())
	return c
}

// DenyIP can be used to deny custom range of IP addresses.
func (c IPConstraint) DenyIP(restrict func(ip net.IP) bool) IPConstraint {
	c.restrictions = append(c.restrictions, restrict)
	return c
}

// InvalidCode overrides default code for violation produced on invalid IP case.
func (c IPConstraint) InvalidCode(code string) IPConstraint {
	c.invalidCode = code
	return c
}

// ProhibitedCode overrides default code for violation produced on prohibited IP case.
func (c IPConstraint) ProhibitedCode(code string) IPConstraint {
	c.prohibitedCode = code
	return c
}

// InvalidMessage sets the violation message template for invalid IP case.
// You can set custom template parameters for injecting its values into the final message.
// Also, you can use default parameters:
//
//	{{ value }} - the current (invalid) value.
func (c IPConstraint) InvalidMessage(template string, parameters ...validation.TemplateParameter) IPConstraint {
	c.invalidMessageTemplate = template
	c.invalidMessageParameters = parameters
	return c
}

// ProhibitedMessage sets the violation message template for prohibited IP case.
// You can set custom template parameters for injecting its values into the final message.
// Also, you can use default parameters:
//
//	{{ value }} - the current (invalid) value.
func (c IPConstraint) ProhibitedMessage(template string, parameters ...validation.TemplateParameter) IPConstraint {
	c.prohibitedMessageTemplate = template
	c.prohibitedMessageParameters = parameters
	return c
}

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

// WhenGroups enables conditional validation of the constraint by using the validation groups.
func (c IPConstraint) WhenGroups(groups ...string) IPConstraint {
	c.groups = groups
	return c
}

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

	return c.validateIP(*value, scope)
}

func (c IPConstraint) validateIP(value string, scope validation.Scope) error {
	err := c.validate(value, c.restrictions...)
	if err == nil {
		return nil
	}

	var builder *validation.ViolationBuilder
	var parameters validation.TemplateParameterList

	if errors.Is(err, validate.ErrProhibited) {
		builder = scope.BuildViolation(c.prohibitedCode, c.prohibitedMessageTemplate)
		parameters = c.prohibitedMessageParameters
	} else {
		builder = scope.BuildViolation(c.invalidCode, c.invalidMessageTemplate)
		parameters = c.invalidMessageParameters
	}

	return builder.
		SetParameters(
			parameters.Prepend(
				validation.TemplateParameter{Key: "{{ value }}", Value: value},
			)...,
		).
		CreateViolation()
}


1		package it
2
3		import (
4		"errors"
5		"net"
6
7		"github.com/muonsoft/validation"
8		"github.com/muonsoft/validation/code"
9		"github.com/muonsoft/validation/is"
10		"github.com/muonsoft/validation/message"
11		"github.com/muonsoft/validation/validate"
12		)
13
14		// IsEmail is used for simplified validation of an email address. It allows all values
15		// with an "@" symbol in, and a "." in the second host part of the email address.
16		func IsEmail() validation.CustomStringConstraint {
17	1	return validation.NewCustomStringConstraint(
18		is.Email,
19		"EmailConstraint",
20		code.InvalidEmail,
21		message.Templates[code.InvalidEmail],
22		)
23		}
24
25		// IsHTML5Email is used for validation of an email address based on pattern for HTML5
26		// (see https://html.spec.whatwg.org/multipage/input.html#valid-e-mail-address).
27		func IsHTML5Email() validation.CustomStringConstraint {
28	1	return validation.NewCustomStringConstraint(
29		is.HTML5Email,
30		"HTML5EmailConstraint",
31		code.InvalidEmail,
32		message.Templates[code.InvalidEmail],
33		)
34		}
35
36		// IsHostname validates that a value is a valid hostname. It checks that:
37		// • each label within a valid hostname may be no more than 63 octets long;
38		// • the total length of the hostname must not exceed 255 characters;
39		// • hostname is fully qualified and include its top-level domain name
40		// (for instance, example.com is valid but example is not);
41		// • checks for reserved top-level domains according to RFC 2606
42		// (hostnames containing them are not considered valid:
43		// .example, .invalid, .localhost, and .test).
44		//
45		// If you do not want to check for top-level domains use IsLooseHostname version of constraint.
46		func IsHostname() validation.CustomStringConstraint {
47	1	return validation.NewCustomStringConstraint(
48		is.StrictHostname,
49		"HostnameConstraint",
50		code.InvalidHostname,
51		message.Templates[code.InvalidHostname],
52		)
53		}
54
55		// IsLooseHostname validates that a value is a valid hostname. It checks that:
56		// • each label within a valid hostname may be no more than 63 octets long;
57		// • the total length of the hostname must not exceed 255 characters.
58		func IsLooseHostname() validation.CustomStringConstraint {
59	1	return validation.NewCustomStringConstraint(
60		is.Hostname,
61		"LooseHostnameConstraint",
62		code.InvalidHostname,
63		message.Templates[code.InvalidHostname],
64		)
65		}
66
67		// URLConstraint is used to validate URL string. This constraint doesn’t check that the host of the
68		// given URL really exists, because the information of the DNS records is not reliable.
69		//
70		// This constraint doesn't check the length of the URL. Use LengthConstraint to check the length of the given value.
71		type URLConstraint struct {
72		isIgnored bool
73		supportsRelativeSchema bool
74		schemas []string
75		groups []string
76		code string
77		messageTemplate string
78		messageParameters validation.TemplateParameterList
79		}
80
81		// IsURL creates a URLConstraint to validate an URL. By default, constraint checks
82		// only for the http:// and https:// schemas. Use the WithSchemas method to configure
83		// the list of expected schemas. Also, you can use WithRelativeSchema to enable support
84		// of the relative schema (without schema, e.g. "//example.com").
85		func IsURL() URLConstraint {
86	1	return URLConstraint{
87		schemas: []string{"http", "https"},
88		code: code.InvalidURL,
89		messageTemplate: message.Templates[code.InvalidURL],
90		}
91		}
92
93		// SetUp will return an error if the list of schemas is empty.
94		func (c URLConstraint) SetUp() error {
95	1	if len(c.schemas) == 0 {
96	1	return errEmptySchemas
97		}
98
99	1	return nil
100		}
101
102		// Name is the constraint name.
103		func (c URLConstraint) Name() string {
104	1	return "URLConstraint"
105		}
106
107		// WithRelativeSchema enables support of relative URL schema, which means that URL value
108		// may be treated as relative (without schema, e.g. "//example.com").
109		func (c URLConstraint) WithRelativeSchema() URLConstraint {
110	1	c.supportsRelativeSchema = true
111	1	return c
112		}
113
114		// WithSchemas is used to set up a list of accepted schemas. For example, if you also consider the ftp:// type URLs
115		// to be valid, redefine the schemas list, listing http, https, and also ftp.
116		// If the list is empty, then an error will be returned by the SetUp method.
117		func (c URLConstraint) WithSchemas(schemas ...string) URLConstraint {
118	1	c.schemas = schemas
119	1	return c
120		}
121
122		// Code overrides default code for produced violation.
123		func (c URLConstraint) Code(code string) URLConstraint {
124	1	c.code = code
125	1	return c
126		}
127
128		// Message sets the violation message template. You can set custom template parameters
129		// for injecting its values into the final message. Also, you can use default parameters:
130		//
131		// {{ value }} - the current (invalid) value.
132		func (c URLConstraint) Message(template string, parameters ...validation.TemplateParameter) URLConstraint {
133	1	c.messageTemplate = template
134	1	c.messageParameters = parameters
135	1	return c
136		}
137
138		// When enables conditional validation of this constraint. If the expression evaluates to false,
139		// then the constraint will be ignored.
140		func (c URLConstraint) When(condition bool) URLConstraint {
141	1	c.isIgnored = !condition
142	1	return c
143		}
144
145		// WhenGroups enables conditional validation of the constraint by using the validation groups.
146		func (c URLConstraint) WhenGroups(groups ...string) URLConstraint {
147	1	c.groups = groups
148	1	return c
149		}
150
151		func (c URLConstraint) ValidateString(value *string, scope validation.Scope) error {
152	1	if c.isIgnored \|\| scope.IsIgnored(c.groups...) \|\| value == nil \|\| *value == "" {
153	1	return nil
154		}
155
156	1	schemas := c.schemas
157	1	if c.supportsRelativeSchema {
158	1	schemas = append(schemas, "")
159		}
160	1	if is.URL(*value, schemas...) {
161	1	return nil
162		}
163
164	1	return scope.BuildViolation(c.code, c.messageTemplate).
165		SetParameters(
166		c.messageParameters.Prepend(
167		validation.TemplateParameter{Key: "{{ value }}", Value: *value},
168		)...,
169		).
170		CreateViolation()
171		}
172
173		// IPConstraint is used to validate IP address. You can check for different versions
174		// and restrict some ranges by additional options.
175		type IPConstraint struct {
176		isIgnored bool
177		validate func(value string, restrictions ...validate.IPRestriction) error
178		restrictions []validate.IPRestriction
179
180		groups []string
181
182		invalidCode string
183		prohibitedCode string
184
185		invalidMessageTemplate string
186		invalidMessageParameters validation.TemplateParameterList
187		prohibitedMessageTemplate string
188		prohibitedMessageParameters validation.TemplateParameterList
189		}
190
191		// IsIP creates an IPConstraint to validate an IP address (IPv4 or IPv6).
192		func IsIP() IPConstraint {
193	1	return newIPConstraint(validate.IP)
194		}
195
196		// IsIPv4 creates an IPConstraint to validate an IPv4 address.
197		func IsIPv4() IPConstraint {
198	1	return newIPConstraint(validate.IPv4)
199		}
200
201		// IsIPv6 creates an IPConstraint to validate an IPv4 address.
202		func IsIPv6() IPConstraint {
203	1	return newIPConstraint(validate.IPv6)
204		}
205
206		func newIPConstraint(validate func(value string, restrictions ...validate.IPRestriction) error) IPConstraint {
207	1	return IPConstraint{
208		validate: validate,
209		invalidCode: code.InvalidIP,
210		prohibitedCode: code.ProhibitedIP,
211		invalidMessageTemplate: message.Templates[code.InvalidIP],
212		prohibitedMessageTemplate: message.Templates[code.ProhibitedIP],
213		}
214		}
215
216		// SetUp always returns no error.
217		func (c IPConstraint) SetUp() error {
218	1	return nil
219		}
220
221		// Name is the constraint name.
222		func (c IPConstraint) Name() string {
223		return "IPConstraint"
224		}
225
226		// DenyPrivateIP denies using of private IPs according to RFC 1918 (IPv4 addresses)
227		// and RFC 4193 (IPv6 addresses).
228		func (c IPConstraint) DenyPrivateIP() IPConstraint {
229	1	c.restrictions = append(c.restrictions, validate.DenyPrivateIP())
230	1	return c
231		}
232
233		// DenyIP can be used to deny custom range of IP addresses.
234		func (c IPConstraint) DenyIP(restrict func(ip net.IP) bool) IPConstraint {
235	1	c.restrictions = append(c.restrictions, restrict)
236	1	return c
237		}
238
239		// InvalidCode overrides default code for violation produced on invalid IP case.
240		func (c IPConstraint) InvalidCode(code string) IPConstraint {
241	1	c.invalidCode = code
242	1	return c
243		}
244
245		// ProhibitedCode overrides default code for violation produced on prohibited IP case.
246		func (c IPConstraint) ProhibitedCode(code string) IPConstraint {
247	1	c.prohibitedCode = code
248	1	return c
249		}
250
251		// InvalidMessage sets the violation message template for invalid IP case.
252		// You can set custom template parameters for injecting its values into the final message.
253		// Also, you can use default parameters:
254		//
255		// {{ value }} - the current (invalid) value.
256		func (c IPConstraint) InvalidMessage(template string, parameters ...validation.TemplateParameter) IPConstraint {
257	1	c.invalidMessageTemplate = template
258	1	c.invalidMessageParameters = parameters
259	1	return c
260		}
261
262		// ProhibitedMessage sets the violation message template for prohibited IP case.
263		// You can set custom template parameters for injecting its values into the final message.
264		// Also, you can use default parameters:
265		//
266		// {{ value }} - the current (invalid) value.
267		func (c IPConstraint) ProhibitedMessage(template string, parameters ...validation.TemplateParameter) IPConstraint {
268	1	c.prohibitedMessageTemplate = template
269	1	c.prohibitedMessageParameters = parameters
270	1	return c
271		}
272
273		// When enables conditional validation of this constraint. If the expression evaluates to false,
274		// then the constraint will be ignored.
275		func (c IPConstraint) When(condition bool) IPConstraint {
276	1	c.isIgnored = !condition
277	1	return c
278		}
279
280		// WhenGroups enables conditional validation of the constraint by using the validation groups.
281		func (c IPConstraint) WhenGroups(groups ...string) IPConstraint {
282	1	c.groups = groups
283	1	return c
284		}
285
286		func (c IPConstraint) ValidateString(value *string, scope validation.Scope) error {
287	1	if c.isIgnored \|\| scope.IsIgnored(c.groups...) \|\| value == nil \|\| *value == "" {
288	1	return nil
289		}
290
291	1	return c.validateIP(*value, scope)
292		}
293
294		func (c IPConstraint) validateIP(value string, scope validation.Scope) error {
295	1	err := c.validate(value, c.restrictions...)
296	1	if err == nil {
297	1	return nil
298		}
299
300	1	var builder *validation.ViolationBuilder
301	1	var parameters validation.TemplateParameterList
302
303	1	if errors.Is(err, validate.ErrProhibited) {
304	1	builder = scope.BuildViolation(c.prohibitedCode, c.prohibitedMessageTemplate)
305	1	parameters = c.prohibitedMessageParameters
306		} else {
307	1	builder = scope.BuildViolation(c.invalidCode, c.invalidMessageTemplate)
308	1	parameters = c.invalidMessageParameters
309		}
310
311	1	return builder.
312		SetParameters(
313		parameters.Prepend(
314		validation.TemplateParameter{Key: "{{ value }}", Value: value},
315		)...,
316		).
317		CreateViolation()
318		}
319

muonsoft / validation

Push — main ( 957b58...866640 )

it.URLConstraint.WithSchemas A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like