From 909d77ef653300318ba174dda58d763550b699cd Mon Sep 17 00:00:00 2001 From: Reuven Harrison Date: Wed, 8 Nov 2023 22:54:11 +0200 Subject: [PATCH] add check descriptions phase 1 (#419) --- .../check-api-operation-id-updated_test.go | 2 +- checker/check-api-security-updated_test.go | 16 +- checker/checker_breaking_test.go | 2 +- checker/checker_deprecation_test.go | 2 +- checker/config.go | 19 +- checker/default_checks.go | 6 +- checker/deprecation.go | 2 +- checker/localizations/lang.go | 11 + checker/localizations/localizations.go | 13 +- checker/localizations_src/en/messages.yaml | 11 + checker/rules.go | 520 +++++++++--------- diff/example_test.go | 2 +- formatters/checks.go | 14 + formatters/format_html_test.go | 2 +- formatters/format_json.go | 2 +- formatters/format_json_test.go | 2 +- formatters/format_text.go | 2 +- formatters/format_text_test.go | 13 +- formatters/format_yaml.go | 2 +- formatters/format_yaml_test.go | 2 +- formatters/interface.go | 7 +- formatters/not_implemented.go | 2 +- formatters/types.go | 2 - internal/breaking_changes.go | 3 +- internal/changelog.go | 5 +- internal/checks.go | 30 +- internal/lang.go | 7 - internal/run_test.go | 2 +- 28 files changed, 382 insertions(+), 321 deletions(-) create mode 100644 checker/localizations/lang.go delete mode 100644 internal/lang.go diff --git a/checker/check-api-operation-id-updated_test.go b/checker/check-api-operation-id-updated_test.go index 9ff68ea0..8d9e83f1 100644 --- a/checker/check-api-operation-id-updated_test.go +++ b/checker/check-api-operation-id-updated_test.go @@ -72,7 +72,7 @@ func TestOperationIdAdded(t *testing.T) { errs := checker.CheckBackwardCompatibilityUntilLevel(singleCheckConfig(checker.APIOperationIdUpdatedCheck), d, osm, checker.INFO) require.Len(t, errs, 1) require.Equal(t, checker.ApiChange{ - Id: "api-operation-id-added", + Id: checker.APIOperationIdAddId, Text: "api operation id 'NewOperationId' was added", Comment: "", Level: checker.INFO, diff --git a/checker/check-api-security-updated_test.go b/checker/check-api-security-updated_test.go index b47fb6f5..e96a916b 100644 --- a/checker/check-api-security-updated_test.go +++ b/checker/check-api-security-updated_test.go @@ -20,7 +20,7 @@ func TestAPIGlobalSecurityyAdded(t *testing.T) { errs := checker.CheckBackwardCompatibilityUntilLevel(singleCheckConfig(checker.APISecurityUpdatedCheck), d, osm, checker.INFO) require.Len(t, errs, 1) require.Equal(t, checker.SecurityChange{ - Id: "api-global-security-added", + Id: checker.APIGlobalSecurityAddedCheckId, Text: "the security scheme 'petstore_auth' was added to the API", Comment: "", Level: checker.INFO, @@ -40,7 +40,7 @@ func TestAPIGlobalSecurityyDeleted(t *testing.T) { errs := checker.CheckBackwardCompatibilityUntilLevel(singleCheckConfig(checker.APISecurityUpdatedCheck), d, osm, checker.INFO) require.Len(t, errs, 1) require.Equal(t, checker.SecurityChange{ - Id: "api-global-security-removed", + Id: checker.APIGlobalSecurityRemovedCheckId, Text: "the security scheme 'petstore_auth' was removed from the API", Comment: "", Level: checker.INFO, @@ -61,7 +61,7 @@ func TestAPIGlobalSecurityScopeRemoved(t *testing.T) { errs := checker.CheckBackwardCompatibilityUntilLevel(singleCheckConfig(checker.APISecurityUpdatedCheck), d, osm, checker.INFO) require.Len(t, errs, 1) require.Equal(t, checker.SecurityChange{ - Id: "api-global-security-scope-removed", + Id: checker.APIGlobalSecurityScopeRemovedId, Text: "the security scope 'read:pets' was removed from the global security scheme 'petstore_auth'", Comment: "", Level: checker.INFO, @@ -82,7 +82,7 @@ func TestAPIGlobalSecurityScopeAdded(t *testing.T) { errs := checker.CheckBackwardCompatibilityUntilLevel(singleCheckConfig(checker.APISecurityUpdatedCheck), d, osm, checker.INFO) require.Len(t, errs, 1) require.Equal(t, checker.SecurityChange{ - Id: "api-global-security-scope-added", + Id: checker.APIGlobalSecurityScopeAddedId, Text: "the security scope 'read:pets' was added to the global security scheme 'petstore_auth'", Comment: "", Level: checker.INFO, @@ -102,7 +102,7 @@ func TestAPISecurityAdded(t *testing.T) { errs := checker.CheckBackwardCompatibilityUntilLevel(singleCheckConfig(checker.APISecurityUpdatedCheck), d, osm, checker.INFO) require.Len(t, errs, 1) require.Equal(t, checker.ApiChange{ - Id: "api-security-added", + Id: checker.APISecurityAddedCheckId, Text: "the endpoint scheme security 'petstore_auth' was added to the API", Comment: "", Level: checker.INFO, @@ -125,7 +125,7 @@ func TestAPISecurityDeleted(t *testing.T) { errs := checker.CheckBackwardCompatibilityUntilLevel(singleCheckConfig(checker.APISecurityUpdatedCheck), d, osm, checker.INFO) require.Len(t, errs, 1) require.Equal(t, checker.ApiChange{ - Id: "api-security-removed", + Id: checker.APISecurityRemovedCheckId, Text: "the endpoint scheme security 'petstore_auth' was removed from the API", Comment: "", Level: checker.INFO, @@ -148,7 +148,7 @@ func TestAPISecurityScopeRemoved(t *testing.T) { errs := checker.CheckBackwardCompatibilityUntilLevel(singleCheckConfig(checker.APISecurityUpdatedCheck), d, osm, checker.INFO) require.Len(t, errs, 1) require.Equal(t, checker.ApiChange{ - Id: "api-security-scope-removed", + Id: checker.APISecurityScopeRemovedId, Text: "the security scope 'read:pets' was removed from the endpoint's security scheme 'petstore_auth'", Comment: "", Level: checker.INFO, @@ -171,7 +171,7 @@ func TestAPISecurityScopeAdded(t *testing.T) { errs := checker.CheckBackwardCompatibilityUntilLevel(singleCheckConfig(checker.APISecurityUpdatedCheck), d, osm, checker.INFO) require.Len(t, errs, 1) require.Equal(t, checker.ApiChange{ - Id: "api-security-scope-added", + Id: checker.APISecurityScopeAddedId, Text: "the security scope 'read:pets' was added to the endpoint's security scheme 'petstore_auth'", Comment: "", Level: checker.INFO, diff --git a/checker/checker_breaking_test.go b/checker/checker_breaking_test.go index 818cf15b..d5b8f411 100644 --- a/checker/checker_breaking_test.go +++ b/checker/checker_breaking_test.go @@ -44,7 +44,7 @@ func getConfig() *diff.Config { func TestBreaking_DeletedPath(t *testing.T) { errs := d(t, getConfig(), 1, 701) require.Len(t, errs, 1) - require.Equal(t, "api-path-removed-without-deprecation", errs[0].GetId()) + require.Equal(t, checker.APIPathRemovedWithoutDeprecationId, errs[0].GetId()) } // BC: deleting an operation is breaking diff --git a/checker/checker_deprecation_test.go b/checker/checker_deprecation_test.go index bed46129..bc528ad4 100644 --- a/checker/checker_deprecation_test.go +++ b/checker/checker_deprecation_test.go @@ -27,7 +27,7 @@ func singleCheckConfig(c checker.BackwardCompatibilityCheck) checker.Config { Checks: []checker.BackwardCompatibilityCheck{c}, MinSunsetBetaDays: 31, MinSunsetStableDays: 180, - Localize: checker.NewLocalizer("en", "en"), + Localize: checker.NewDefaultLocalizer(), } } diff --git a/checker/config.go b/checker/config.go index 01030c09..1566a32f 100644 --- a/checker/config.go +++ b/checker/config.go @@ -8,11 +8,22 @@ import ( type Localizer func(key string, args ...interface{}) string -func NewLocalizer(locale string, fallbackLocale string) Localizer { - locales := localizations.New(locale, fallbackLocale) +func NewDefaultLocalizer() Localizer { + return NewLocalizer(localizations.LangDefault) +} + +func NewLocalizer(locale string) Localizer { + locales := localizations.New(locale, localizations.LangDefault) + + return func(originalKey string, args ...interface{}) string { + key := "messages." + originalKey + pattern := locales.Get(key) - return func(key string, args ...interface{}) string { - pattern := locales.Get("messages." + key) + // if key not found, return original key + // TODO: improve localizations to return error when key not found + if pattern == key { + return originalKey + } return fmt.Sprintf(pattern, args...) } diff --git a/checker/default_checks.go b/checker/default_checks.go index 1a7b6df8..07d875cc 100644 --- a/checker/default_checks.go +++ b/checker/default_checks.go @@ -35,12 +35,12 @@ func getBackwardCompatibilityCheckConfig(checks []BackwardCompatibilityCheck, le LogLevelOverrides: levelOverrides, MinSunsetBetaDays: minSunsetBetaDays, MinSunsetStableDays: minSunsetStableDays, - Localize: NewLocalizer("en", "en"), + Localize: NewDefaultLocalizer(), } } func optionalChecks() map[string]BackwardCompatibilityCheck { - optionalRules := GetOptionalRules() + optionalRules := GetOptionalRules(NewDefaultLocalizer()) result := make(map[string]BackwardCompatibilityCheck, len(optionalRules)) for _, rule := range optionalRules { @@ -66,7 +66,7 @@ func defaultChecks() []BackwardCompatibilityCheck { result := []BackwardCompatibilityCheck{} m := utils.StringSet{} - for _, rule := range GetRequiredRules() { + for _, rule := range GetRequiredRules(NewDefaultLocalizer()) { pStr := fmt.Sprintf("%v", rule.Handler) if !m.Contains(pStr) { m.Add(pStr) diff --git a/checker/deprecation.go b/checker/deprecation.go index 9a3b6d5d..fc39e5b2 100644 --- a/checker/deprecation.go +++ b/checker/deprecation.go @@ -19,7 +19,7 @@ func getSunsetDate(Extensions map[string]interface{}) (string, civil.Date, error if !ok { sunsetJson, ok := Extensions[diff.SunsetExtension].(json.RawMessage) if !ok { - return "", civil.Date{}, errors.New("sunset header not found") + return "", civil.Date{}, errors.New("sunset extension not found") } if err := json.Unmarshal(sunsetJson, &sunset); err != nil { return "", civil.Date{}, errors.New("unmarshal failed") diff --git a/checker/localizations/lang.go b/checker/localizations/lang.go new file mode 100644 index 00000000..9fcebf35 --- /dev/null +++ b/checker/localizations/lang.go @@ -0,0 +1,11 @@ +package localizations + +const ( + LangDefault = LangEn + LangEn = "en" + LangRu = "ru" +) + +func GetSupportedLanguages() []string { + return []string{LangEn, LangRu} +} diff --git a/checker/localizations/localizations.go b/checker/localizations/localizations.go index 9d00fd47..b456e5d5 100644 --- a/checker/localizations/localizations.go +++ b/checker/localizations/localizations.go @@ -1,6 +1,6 @@ // Code generated by go-localize; DO NOT EDIT. // This file was generated by robots at -// 2023-09-11 16:39:50.19002 +0300 IDT m=+0.007249459 +// 2023-11-08 22:43:30.081427 +0200 IST m=+0.004297753 package localizations @@ -13,15 +13,25 @@ import ( var localizations = map[string]string{ "en.messages.added-required-request-body": "added required request body", + "en.messages.added-required-request-body-description": "a new required request body was added", "en.messages.api-deprecated-sunset-parse": "api sunset date '%s' can't be parsed for deprecated API: %v", + "en.messages.api-deprecated-sunset-parse-description": "invalid or missing sunset extension", "en.messages.api-global-security-added": "the security scheme %s was added to the API", + "en.messages.api-global-security-added-description": "a new security scheme was added under security", "en.messages.api-global-security-removed": "the security scheme %s was removed from the API", + "en.messages.api-global-security-removed-description": "a security scheme was deleted under security", "en.messages.api-global-security-scope-added": "the security scope %s was added to the global security scheme %s", + "en.messages.api-global-security-scope-added-description": "a new scope was added to a security scheme under security", "en.messages.api-global-security-scope-removed": "the security scope %s was removed from the global security scheme %s", + "en.messages.api-global-security-scope-removed-description": "a scope was deleted from a security scheme under security", "en.messages.api-operation-id-added": "api operation id %s was added", + "en.messages.api-operation-id-added-description": "an operation ID was added to an endpoint", "en.messages.api-operation-id-removed": "api operation id %s removed and replaced with %s", + "en.messages.api-operation-id-removed-description": "an operation ID was deleted from an endpoint", "en.messages.api-path-removed-before-sunset": "api path removed before the sunset date %s", + "en.messages.api-path-removed-before-sunset-description": "an endpoint was deleted before sunset date", "en.messages.api-path-removed-without-deprecation": "api path removed without deprecation", + "en.messages.api-path-removed-without-deprecation-description": "an endpoint was deleted without deprecation", "en.messages.api-removed-before-sunset": "api removed before the sunset date %s", "en.messages.api-removed-without-deprecation": "api removed without deprecation", "en.messages.api-schema-removed": "removed the schema %s", @@ -43,6 +53,7 @@ var localizations = map[string]string{ "en.messages.api-tag-removed": "api tag %s removed", "en.messages.at": "at", "en.messages.endpoint-added": "endpoint added", + "en.messages.endpoint-added-description": "a new endpoint was added", "en.messages.endpoint-deprecated": "endpoint deprecated", "en.messages.endpoint-reactivated": "endpoint reactivated", "en.messages.in": "in", diff --git a/checker/localizations_src/en/messages.yaml b/checker/localizations_src/en/messages.yaml index 39440083..0b120726 100644 --- a/checker/localizations_src/en/messages.yaml +++ b/checker/localizations_src/en/messages.yaml @@ -264,3 +264,14 @@ request-required-property-became-write-only: the request required property %s be request-required-property-became-not-write-only: the request required property %s became not write-only new-required-request-default-parameter-to-existing-path: added the new required %s request parameter %s to all path's operations new-optional-request-default-parameter-to-existing-path: added the new optional %s request parameter %s to all path's operations +added-required-request-body-description: a new required request body was added +api-deprecated-sunset-parse-description: invalid or missing sunset extension +endpoint-added-description: a new endpoint was added +api-global-security-added-description: a new security scheme was added under security +api-global-security-removed-description: a security scheme was deleted under security +api-global-security-scope-added-description: a new scope was added to a security scheme under security +api-global-security-scope-removed-description: a scope was deleted from a security scheme under security +api-operation-id-added-description: an operation ID was added to an endpoint +api-operation-id-removed-description: an operation ID was deleted from an endpoint +api-path-removed-before-sunset-description: an endpoint was deleted before sunset date +api-path-removed-without-deprecation-description: an endpoint was deleted without deprecation \ No newline at end of file diff --git a/checker/rules.go b/checker/rules.go index 50491364..810dd3e4 100644 --- a/checker/rules.go +++ b/checker/rules.go @@ -1,367 +1,371 @@ package checker -func newBackwardCompatibilityRule(id string, level Level, required bool, handler BackwardCompatibilityCheck) BackwardCompatibilityRule { +func getDescription(l Localizer, id string) string { + return l(id + "-description") +} + +func newBackwardCompatibilityRule(l Localizer, id string, level Level, required bool, handler BackwardCompatibilityCheck) BackwardCompatibilityRule { return BackwardCompatibilityRule{ Id: id, Level: level, - Description: id + "-description", // TODO: rule descriptions are still missing as of now + Description: getDescription(l, id), Required: required, Handler: handler, } } -func GetAllRules() []BackwardCompatibilityRule { +func GetAllRules(l Localizer) []BackwardCompatibilityRule { return []BackwardCompatibilityRule{ // APIAddedCheck - newBackwardCompatibilityRule(EndpointAddedId, INFO, true, APIAddedCheck), + newBackwardCompatibilityRule(l, EndpointAddedId, INFO, true, APIAddedCheck), // APIComponentsSecurityUpdatedCheck - newBackwardCompatibilityRule(APIComponentsSecurityRemovedId, INFO, true, APIComponentsSecurityUpdatedCheck), - newBackwardCompatibilityRule(APIComponentsSecurityAddedId, INFO, true, APIComponentsSecurityUpdatedCheck), - newBackwardCompatibilityRule(APIComponentsSecurityComponentOauthUrlUpdatedId, INFO, true, APIComponentsSecurityUpdatedCheck), - newBackwardCompatibilityRule(APIComponentsSecurityTypeUpdatedId, INFO, true, APIComponentsSecurityUpdatedCheck), - newBackwardCompatibilityRule(APIComponentsSecurityOauthTokenUrlUpdatedId, INFO, true, APIComponentsSecurityUpdatedCheck), - newBackwardCompatibilityRule(APIComponentSecurityOauthScopeAddedId, INFO, true, APIComponentsSecurityUpdatedCheck), - newBackwardCompatibilityRule(APIComponentSecurityOauthScopeRemovedId, INFO, true, APIComponentsSecurityUpdatedCheck), - newBackwardCompatibilityRule(APIComponentSecurityOauthScopeUpdatedId, INFO, true, APIComponentsSecurityUpdatedCheck), + newBackwardCompatibilityRule(l, APIComponentsSecurityRemovedId, INFO, true, APIComponentsSecurityUpdatedCheck), + newBackwardCompatibilityRule(l, APIComponentsSecurityAddedId, INFO, true, APIComponentsSecurityUpdatedCheck), + newBackwardCompatibilityRule(l, APIComponentsSecurityComponentOauthUrlUpdatedId, INFO, true, APIComponentsSecurityUpdatedCheck), + newBackwardCompatibilityRule(l, APIComponentsSecurityTypeUpdatedId, INFO, true, APIComponentsSecurityUpdatedCheck), + newBackwardCompatibilityRule(l, APIComponentsSecurityOauthTokenUrlUpdatedId, INFO, true, APIComponentsSecurityUpdatedCheck), + newBackwardCompatibilityRule(l, APIComponentSecurityOauthScopeAddedId, INFO, true, APIComponentsSecurityUpdatedCheck), + newBackwardCompatibilityRule(l, APIComponentSecurityOauthScopeRemovedId, INFO, true, APIComponentsSecurityUpdatedCheck), + newBackwardCompatibilityRule(l, APIComponentSecurityOauthScopeUpdatedId, INFO, true, APIComponentsSecurityUpdatedCheck), // APISecurityUpdatedCheck - newBackwardCompatibilityRule(APISecurityRemovedCheckId, INFO, true, APISecurityUpdatedCheck), - newBackwardCompatibilityRule(APISecurityAddedCheckId, INFO, true, APISecurityUpdatedCheck), - newBackwardCompatibilityRule(APISecurityScopeAddedId, INFO, true, APISecurityUpdatedCheck), - newBackwardCompatibilityRule(APISecurityScopeRemovedId, INFO, true, APISecurityUpdatedCheck), - newBackwardCompatibilityRule(APIGlobalSecurityRemovedCheckId, INFO, true, APISecurityUpdatedCheck), - newBackwardCompatibilityRule(APIGlobalSecurityAddedCheckId, INFO, true, APISecurityUpdatedCheck), - newBackwardCompatibilityRule(APIGlobalSecurityScopeAddedId, INFO, true, APISecurityUpdatedCheck), - newBackwardCompatibilityRule(APIGlobalSecurityScopeRemovedId, INFO, true, APISecurityUpdatedCheck), + newBackwardCompatibilityRule(l, APISecurityRemovedCheckId, INFO, true, APISecurityUpdatedCheck), + newBackwardCompatibilityRule(l, APISecurityAddedCheckId, INFO, true, APISecurityUpdatedCheck), + newBackwardCompatibilityRule(l, APISecurityScopeAddedId, INFO, true, APISecurityUpdatedCheck), + newBackwardCompatibilityRule(l, APISecurityScopeRemovedId, INFO, true, APISecurityUpdatedCheck), + newBackwardCompatibilityRule(l, APIGlobalSecurityRemovedCheckId, INFO, true, APISecurityUpdatedCheck), + newBackwardCompatibilityRule(l, APIGlobalSecurityAddedCheckId, INFO, true, APISecurityUpdatedCheck), + newBackwardCompatibilityRule(l, APIGlobalSecurityScopeAddedId, INFO, true, APISecurityUpdatedCheck), + newBackwardCompatibilityRule(l, APIGlobalSecurityScopeRemovedId, INFO, true, APISecurityUpdatedCheck), // APIDeprecationCheck - newBackwardCompatibilityRule(EndpointReactivatedId, INFO, true, APIDeprecationCheck), - newBackwardCompatibilityRule(APIDeprecatedSunsetParseId, ERR, true, APIDeprecationCheck), - newBackwardCompatibilityRule(ParseErrorId, ERR, true, APIDeprecationCheck), - newBackwardCompatibilityRule(APISunsetDateTooSmallId, ERR, true, APIDeprecationCheck), - newBackwardCompatibilityRule(EndpointDeprecatedId, INFO, true, APIDeprecationCheck), + newBackwardCompatibilityRule(l, EndpointReactivatedId, INFO, true, APIDeprecationCheck), + newBackwardCompatibilityRule(l, APIDeprecatedSunsetParseId, ERR, true, APIDeprecationCheck), + newBackwardCompatibilityRule(l, ParseErrorId, ERR, true, APIDeprecationCheck), + newBackwardCompatibilityRule(l, APISunsetDateTooSmallId, ERR, true, APIDeprecationCheck), + newBackwardCompatibilityRule(l, EndpointDeprecatedId, INFO, true, APIDeprecationCheck), // APIRemovedCheck - newBackwardCompatibilityRule(APIPathRemovedWithoutDeprecationId, ERR, true, APIRemovedCheck), - newBackwardCompatibilityRule(APIPathSunsetParseId, ERR, true, APIRemovedCheck), - newBackwardCompatibilityRule(APIPathRemovedBeforeSunsetId, ERR, true, APIRemovedCheck), - newBackwardCompatibilityRule(APIRemovedWithoutDeprecationId, ERR, true, APIRemovedCheck), - newBackwardCompatibilityRule(APIRemovedBeforeSunsetId, ERR, true, APIRemovedCheck), + newBackwardCompatibilityRule(l, APIPathRemovedWithoutDeprecationId, ERR, true, APIRemovedCheck), + newBackwardCompatibilityRule(l, APIPathSunsetParseId, ERR, true, APIRemovedCheck), + newBackwardCompatibilityRule(l, APIPathRemovedBeforeSunsetId, ERR, true, APIRemovedCheck), + newBackwardCompatibilityRule(l, APIRemovedWithoutDeprecationId, ERR, true, APIRemovedCheck), + newBackwardCompatibilityRule(l, APIRemovedBeforeSunsetId, ERR, true, APIRemovedCheck), // APISunsetChangedCheck - newBackwardCompatibilityRule(APISunsetDeletedId, ERR, true, APISunsetChangedCheck), - newBackwardCompatibilityRule(APISunsetDateChangedTooSmallId, ERR, true, APISunsetChangedCheck), + newBackwardCompatibilityRule(l, APISunsetDeletedId, ERR, true, APISunsetChangedCheck), + newBackwardCompatibilityRule(l, APISunsetDateChangedTooSmallId, ERR, true, APISunsetChangedCheck), // AddedRequiredRequestBodyCheck - newBackwardCompatibilityRule(AddedRequiredRequestBodyId, ERR, true, AddedRequiredRequestBodyCheck), + newBackwardCompatibilityRule(l, AddedRequiredRequestBodyId, ERR, true, AddedRequiredRequestBodyCheck), // NewRequestNonPathDefaultParameterCheck - newBackwardCompatibilityRule(NewRequiredRequestDefaultParameterToExistingPathId, ERR, true, NewRequestNonPathDefaultParameterCheck), - newBackwardCompatibilityRule(NewOptionalRequestDefaultParameterToExistingPathId, INFO, true, NewRequestNonPathDefaultParameterCheck), + newBackwardCompatibilityRule(l, NewRequiredRequestDefaultParameterToExistingPathId, ERR, true, NewRequestNonPathDefaultParameterCheck), + newBackwardCompatibilityRule(l, NewOptionalRequestDefaultParameterToExistingPathId, INFO, true, NewRequestNonPathDefaultParameterCheck), // NewRequestNonPathParameterCheck - newBackwardCompatibilityRule(NewRequiredRequestParameterId, ERR, true, NewRequestNonPathParameterCheck), - newBackwardCompatibilityRule(NewOptionalRequestParameterId, INFO, true, NewRequestNonPathParameterCheck), + newBackwardCompatibilityRule(l, NewRequiredRequestParameterId, ERR, true, NewRequestNonPathParameterCheck), + newBackwardCompatibilityRule(l, NewOptionalRequestParameterId, INFO, true, NewRequestNonPathParameterCheck), // NewRequestPathParameterCheck - newBackwardCompatibilityRule(NewRequestPathParameterId, ERR, true, NewRequestPathParameterCheck), + newBackwardCompatibilityRule(l, NewRequestPathParameterId, ERR, true, NewRequestPathParameterCheck), // NewRequiredRequestHeaderPropertyCheck - newBackwardCompatibilityRule(NewRequiredRequestHeaderPropertyId, ERR, true, NewRequiredRequestHeaderPropertyCheck), + newBackwardCompatibilityRule(l, NewRequiredRequestHeaderPropertyId, ERR, true, NewRequiredRequestHeaderPropertyCheck), // RequestBodyBecameEnumCheck - newBackwardCompatibilityRule(RequestBodyBecameEnumId, ERR, true, RequestBodyBecameEnumCheck), + newBackwardCompatibilityRule(l, RequestBodyBecameEnumId, ERR, true, RequestBodyBecameEnumCheck), // RequestBodyMediaTypeChangedCheck - newBackwardCompatibilityRule(RequestBodyMediaTypeAddedId, INFO, true, RequestBodyMediaTypeChangedCheck), - newBackwardCompatibilityRule(RequestBodyMediaTypeRemovedId, ERR, true, RequestBodyMediaTypeChangedCheck), + newBackwardCompatibilityRule(l, RequestBodyMediaTypeAddedId, INFO, true, RequestBodyMediaTypeChangedCheck), + newBackwardCompatibilityRule(l, RequestBodyMediaTypeRemovedId, ERR, true, RequestBodyMediaTypeChangedCheck), // RequestBodyRequiredUpdatedCheck - newBackwardCompatibilityRule(RequestBodyBecameOptionalId, INFO, true, RequestBodyRequiredUpdatedCheck), - newBackwardCompatibilityRule(RequestBodyBecameRequiredId, ERR, true, RequestBodyRequiredUpdatedCheck), + newBackwardCompatibilityRule(l, RequestBodyBecameOptionalId, INFO, true, RequestBodyRequiredUpdatedCheck), + newBackwardCompatibilityRule(l, RequestBodyBecameRequiredId, ERR, true, RequestBodyRequiredUpdatedCheck), // RequestDiscriminatorUpdatedCheck - newBackwardCompatibilityRule(RequestBodyDiscriminatorAddedId, INFO, true, RequestDiscriminatorUpdatedCheck), - newBackwardCompatibilityRule(RequestBodyDiscriminatorRemovedId, INFO, true, RequestDiscriminatorUpdatedCheck), - newBackwardCompatibilityRule(RequestBodyDiscriminatorPropertyNameChangedId, INFO, true, RequestDiscriminatorUpdatedCheck), - newBackwardCompatibilityRule(RequestBodyDiscriminatorMappingAddedId, INFO, true, RequestDiscriminatorUpdatedCheck), - newBackwardCompatibilityRule(RequestBodyDiscriminatorMappingDeletedId, INFO, true, RequestDiscriminatorUpdatedCheck), - newBackwardCompatibilityRule(RequestBodyDiscriminatorMappingChangedId, INFO, true, RequestDiscriminatorUpdatedCheck), - newBackwardCompatibilityRule(RequestPropertyDiscriminatorAddedId, INFO, true, RequestDiscriminatorUpdatedCheck), - newBackwardCompatibilityRule(RequestPropertyDiscriminatorRemovedId, INFO, true, RequestDiscriminatorUpdatedCheck), - newBackwardCompatibilityRule(RequestPropertyDiscriminatorPropertyNameChangedId, INFO, true, RequestDiscriminatorUpdatedCheck), - newBackwardCompatibilityRule(RequestPropertyDiscriminatorMappingAddedId, INFO, true, RequestDiscriminatorUpdatedCheck), - newBackwardCompatibilityRule(RequestPropertyDiscriminatorMappingDeletedId, INFO, true, RequestDiscriminatorUpdatedCheck), - newBackwardCompatibilityRule(RequestPropertyDiscriminatorMappingChangedId, INFO, true, RequestDiscriminatorUpdatedCheck), + newBackwardCompatibilityRule(l, RequestBodyDiscriminatorAddedId, INFO, true, RequestDiscriminatorUpdatedCheck), + newBackwardCompatibilityRule(l, RequestBodyDiscriminatorRemovedId, INFO, true, RequestDiscriminatorUpdatedCheck), + newBackwardCompatibilityRule(l, RequestBodyDiscriminatorPropertyNameChangedId, INFO, true, RequestDiscriminatorUpdatedCheck), + newBackwardCompatibilityRule(l, RequestBodyDiscriminatorMappingAddedId, INFO, true, RequestDiscriminatorUpdatedCheck), + newBackwardCompatibilityRule(l, RequestBodyDiscriminatorMappingDeletedId, INFO, true, RequestDiscriminatorUpdatedCheck), + newBackwardCompatibilityRule(l, RequestBodyDiscriminatorMappingChangedId, INFO, true, RequestDiscriminatorUpdatedCheck), + newBackwardCompatibilityRule(l, RequestPropertyDiscriminatorAddedId, INFO, true, RequestDiscriminatorUpdatedCheck), + newBackwardCompatibilityRule(l, RequestPropertyDiscriminatorRemovedId, INFO, true, RequestDiscriminatorUpdatedCheck), + newBackwardCompatibilityRule(l, RequestPropertyDiscriminatorPropertyNameChangedId, INFO, true, RequestDiscriminatorUpdatedCheck), + newBackwardCompatibilityRule(l, RequestPropertyDiscriminatorMappingAddedId, INFO, true, RequestDiscriminatorUpdatedCheck), + newBackwardCompatibilityRule(l, RequestPropertyDiscriminatorMappingDeletedId, INFO, true, RequestDiscriminatorUpdatedCheck), + newBackwardCompatibilityRule(l, RequestPropertyDiscriminatorMappingChangedId, INFO, true, RequestDiscriminatorUpdatedCheck), // RequestHeaderPropertyBecameEnumCheck - newBackwardCompatibilityRule(RequestHeaderPropertyBecameEnumId, ERR, true, RequestHeaderPropertyBecameEnumCheck), + newBackwardCompatibilityRule(l, RequestHeaderPropertyBecameEnumId, ERR, true, RequestHeaderPropertyBecameEnumCheck), // RequestHeaderPropertyBecameRequiredCheck - newBackwardCompatibilityRule(RequestHeaderPropertyBecameRequiredId, ERR, true, RequestHeaderPropertyBecameRequiredCheck), + newBackwardCompatibilityRule(l, RequestHeaderPropertyBecameRequiredId, ERR, true, RequestHeaderPropertyBecameRequiredCheck), // RequestParameterBecameEnumCheck - newBackwardCompatibilityRule(RequestParameterBecameEnumId, ERR, true, RequestParameterBecameEnumCheck), + newBackwardCompatibilityRule(l, RequestParameterBecameEnumId, ERR, true, RequestParameterBecameEnumCheck), // RequestParameterDefaultValueChangedCheck - newBackwardCompatibilityRule(RequestParameterDefaultValueChangedId, ERR, true, RequestParameterDefaultValueChangedCheck), - newBackwardCompatibilityRule(RequestParameterDefaultValueAddedId, ERR, true, RequestParameterDefaultValueChangedCheck), - newBackwardCompatibilityRule(RequestParameterDefaultValueRemovedId, ERR, true, RequestParameterDefaultValueChangedCheck), + newBackwardCompatibilityRule(l, RequestParameterDefaultValueChangedId, ERR, true, RequestParameterDefaultValueChangedCheck), + newBackwardCompatibilityRule(l, RequestParameterDefaultValueAddedId, ERR, true, RequestParameterDefaultValueChangedCheck), + newBackwardCompatibilityRule(l, RequestParameterDefaultValueRemovedId, ERR, true, RequestParameterDefaultValueChangedCheck), // RequestParameterEnumValueUpdatedCheck - newBackwardCompatibilityRule(RequestParameterEnumValueAddedId, INFO, true, RequestParameterEnumValueUpdatedCheck), - newBackwardCompatibilityRule(RequestParameterEnumValueRemovedId, ERR, true, RequestParameterEnumValueUpdatedCheck), + newBackwardCompatibilityRule(l, RequestParameterEnumValueAddedId, INFO, true, RequestParameterEnumValueUpdatedCheck), + newBackwardCompatibilityRule(l, RequestParameterEnumValueRemovedId, ERR, true, RequestParameterEnumValueUpdatedCheck), // RequestParameterMaxItemsUpdatedCheck - newBackwardCompatibilityRule(RequestParameterMaxItemsIncreasedId, INFO, true, RequestParameterMaxItemsUpdatedCheck), - newBackwardCompatibilityRule(RequestParameterMaxItemsDecreasedId, ERR, true, RequestParameterMaxItemsUpdatedCheck), + newBackwardCompatibilityRule(l, RequestParameterMaxItemsIncreasedId, INFO, true, RequestParameterMaxItemsUpdatedCheck), + newBackwardCompatibilityRule(l, RequestParameterMaxItemsDecreasedId, ERR, true, RequestParameterMaxItemsUpdatedCheck), // RequestParameterMaxLengthSetCheck - newBackwardCompatibilityRule(RequestParameterMaxLengthSetId, WARN, true, RequestParameterMaxLengthSetCheck), + newBackwardCompatibilityRule(l, RequestParameterMaxLengthSetId, WARN, true, RequestParameterMaxLengthSetCheck), // RequestParameterMaxLengthUpdatedCheck - newBackwardCompatibilityRule(RequestParameterMaxLengthIncreasedId, INFO, true, RequestParameterMaxLengthUpdatedCheck), - newBackwardCompatibilityRule(RequestParameterMaxLengthDecreasedId, ERR, true, RequestParameterMaxLengthUpdatedCheck), + newBackwardCompatibilityRule(l, RequestParameterMaxLengthIncreasedId, INFO, true, RequestParameterMaxLengthUpdatedCheck), + newBackwardCompatibilityRule(l, RequestParameterMaxLengthDecreasedId, ERR, true, RequestParameterMaxLengthUpdatedCheck), // RequestParameterMaxSetCheck - newBackwardCompatibilityRule(RequestParameterMaxSetId, WARN, true, RequestParameterMaxSetCheck), + newBackwardCompatibilityRule(l, RequestParameterMaxSetId, WARN, true, RequestParameterMaxSetCheck), // RequestParameterMaxUpdatedCheck - newBackwardCompatibilityRule(RequestParameterMaxIncreasedId, INFO, true, RequestParameterMaxUpdatedCheck), - newBackwardCompatibilityRule(RequestParameterMaxDecreasedId, ERR, true, RequestParameterMaxUpdatedCheck), + newBackwardCompatibilityRule(l, RequestParameterMaxIncreasedId, INFO, true, RequestParameterMaxUpdatedCheck), + newBackwardCompatibilityRule(l, RequestParameterMaxDecreasedId, ERR, true, RequestParameterMaxUpdatedCheck), // RequestParameterMinItemsSetCheck - newBackwardCompatibilityRule(RequestParameterMinItemsSetId, WARN, true, RequestParameterMinItemsSetCheck), + newBackwardCompatibilityRule(l, RequestParameterMinItemsSetId, WARN, true, RequestParameterMinItemsSetCheck), // RequestParameterMinItemsUpdatedCheck - newBackwardCompatibilityRule(RequestParameterMinItemsIncreasedId, ERR, true, RequestParameterMinItemsUpdatedCheck), - newBackwardCompatibilityRule(RequestParameterMinItemsDecreasedId, INFO, true, RequestParameterMinItemsUpdatedCheck), + newBackwardCompatibilityRule(l, RequestParameterMinItemsIncreasedId, ERR, true, RequestParameterMinItemsUpdatedCheck), + newBackwardCompatibilityRule(l, RequestParameterMinItemsDecreasedId, INFO, true, RequestParameterMinItemsUpdatedCheck), // RequestParameterMinLengthUpdatedCheck - newBackwardCompatibilityRule(RequestParameterMinLengthIncreasedId, ERR, true, RequestParameterMinLengthUpdatedCheck), - newBackwardCompatibilityRule(RequestParameterMinLengthDecreasedId, INFO, true, RequestParameterMinLengthUpdatedCheck), + newBackwardCompatibilityRule(l, RequestParameterMinLengthIncreasedId, ERR, true, RequestParameterMinLengthUpdatedCheck), + newBackwardCompatibilityRule(l, RequestParameterMinLengthDecreasedId, INFO, true, RequestParameterMinLengthUpdatedCheck), // RequestParameterMinSetCheck - newBackwardCompatibilityRule(RequestParameterMinSetId, WARN, true, RequestParameterMinSetCheck), + newBackwardCompatibilityRule(l, RequestParameterMinSetId, WARN, true, RequestParameterMinSetCheck), // RequestParameterMinUpdatedCheck - newBackwardCompatibilityRule(RequestParameterMinIncreasedId, ERR, true, RequestParameterMinUpdatedCheck), - newBackwardCompatibilityRule(RequestParameterMinDecreasedId, INFO, true, RequestParameterMinUpdatedCheck), + newBackwardCompatibilityRule(l, RequestParameterMinIncreasedId, ERR, true, RequestParameterMinUpdatedCheck), + newBackwardCompatibilityRule(l, RequestParameterMinDecreasedId, INFO, true, RequestParameterMinUpdatedCheck), // RequestParameterPatternAddedOrChangedCheck - newBackwardCompatibilityRule(RequestParameterPatternAddedId, WARN, true, RequestParameterPatternAddedOrChangedCheck), - newBackwardCompatibilityRule(RequestParameterPatternRemovedId, INFO, true, RequestParameterPatternAddedOrChangedCheck), - newBackwardCompatibilityRule(RequestParameterPatternChangedId, WARN, true, RequestParameterPatternAddedOrChangedCheck), + newBackwardCompatibilityRule(l, RequestParameterPatternAddedId, WARN, true, RequestParameterPatternAddedOrChangedCheck), + newBackwardCompatibilityRule(l, RequestParameterPatternRemovedId, INFO, true, RequestParameterPatternAddedOrChangedCheck), + newBackwardCompatibilityRule(l, RequestParameterPatternChangedId, WARN, true, RequestParameterPatternAddedOrChangedCheck), // RequestParameterRemovedCheck - newBackwardCompatibilityRule(RequestParameterRemovedId, WARN, true, RequestParameterRemovedCheck), + newBackwardCompatibilityRule(l, RequestParameterRemovedId, WARN, true, RequestParameterRemovedCheck), // RequestParameterRequiredValueUpdatedCheck - newBackwardCompatibilityRule(RequestParameterBecomeRequiredId, ERR, true, RequestParameterRequiredValueUpdatedCheck), - newBackwardCompatibilityRule(RequestParameterBecomeOptionalId, INFO, true, RequestParameterRequiredValueUpdatedCheck), + newBackwardCompatibilityRule(l, RequestParameterBecomeRequiredId, ERR, true, RequestParameterRequiredValueUpdatedCheck), + newBackwardCompatibilityRule(l, RequestParameterBecomeOptionalId, INFO, true, RequestParameterRequiredValueUpdatedCheck), // RequestParameterTypeChangedCheck - newBackwardCompatibilityRule(RequestParameterTypeChangedId, ERR, true, RequestParameterTypeChangedCheck), + newBackwardCompatibilityRule(l, RequestParameterTypeChangedId, ERR, true, RequestParameterTypeChangedCheck), // RequestParameterXExtensibleEnumValueRemovedCheck - newBackwardCompatibilityRule(UnparsableParameterFromXExtensibleEnumId, ERR, true, RequestParameterXExtensibleEnumValueRemovedCheck), - newBackwardCompatibilityRule(UnparsableParameterToXExtensibleEnumId, ERR, true, RequestParameterXExtensibleEnumValueRemovedCheck), - newBackwardCompatibilityRule(RequestParameterXExtensibleEnumValueRemovedId, ERR, true, RequestParameterXExtensibleEnumValueRemovedCheck), + newBackwardCompatibilityRule(l, UnparsableParameterFromXExtensibleEnumId, ERR, true, RequestParameterXExtensibleEnumValueRemovedCheck), + newBackwardCompatibilityRule(l, UnparsableParameterToXExtensibleEnumId, ERR, true, RequestParameterXExtensibleEnumValueRemovedCheck), + newBackwardCompatibilityRule(l, RequestParameterXExtensibleEnumValueRemovedId, ERR, true, RequestParameterXExtensibleEnumValueRemovedCheck), // RequestPropertyAllOfUpdatedCheck - newBackwardCompatibilityRule(RequestBodyAllOfAddedId, ERR, true, RequestPropertyAllOfUpdatedCheck), - newBackwardCompatibilityRule(RequestBodyAllOfRemovedId, WARN, true, RequestPropertyAllOfUpdatedCheck), - newBackwardCompatibilityRule(RequestPropertyAllOfAddedId, ERR, true, RequestPropertyAllOfUpdatedCheck), - newBackwardCompatibilityRule(RequestPropertyAllOfRemovedId, WARN, true, RequestPropertyAllOfUpdatedCheck), + newBackwardCompatibilityRule(l, RequestBodyAllOfAddedId, ERR, true, RequestPropertyAllOfUpdatedCheck), + newBackwardCompatibilityRule(l, RequestBodyAllOfRemovedId, WARN, true, RequestPropertyAllOfUpdatedCheck), + newBackwardCompatibilityRule(l, RequestPropertyAllOfAddedId, ERR, true, RequestPropertyAllOfUpdatedCheck), + newBackwardCompatibilityRule(l, RequestPropertyAllOfRemovedId, WARN, true, RequestPropertyAllOfUpdatedCheck), // RequestPropertyAnyOfUpdatedCheck - newBackwardCompatibilityRule(RequestBodyAnyOfAddedId, INFO, true, RequestPropertyAnyOfUpdatedCheck), - newBackwardCompatibilityRule(RequestBodyAnyOfRemovedId, ERR, true, RequestPropertyAnyOfUpdatedCheck), - newBackwardCompatibilityRule(RequestPropertyAnyOfAddedId, INFO, true, RequestPropertyAnyOfUpdatedCheck), - newBackwardCompatibilityRule(RequestPropertyAnyOfRemovedId, ERR, true, RequestPropertyAnyOfUpdatedCheck), + newBackwardCompatibilityRule(l, RequestBodyAnyOfAddedId, INFO, true, RequestPropertyAnyOfUpdatedCheck), + newBackwardCompatibilityRule(l, RequestBodyAnyOfRemovedId, ERR, true, RequestPropertyAnyOfUpdatedCheck), + newBackwardCompatibilityRule(l, RequestPropertyAnyOfAddedId, INFO, true, RequestPropertyAnyOfUpdatedCheck), + newBackwardCompatibilityRule(l, RequestPropertyAnyOfRemovedId, ERR, true, RequestPropertyAnyOfUpdatedCheck), // RequestPropertyBecameEnumCheck - newBackwardCompatibilityRule(RequestPropertyBecameEnumId, ERR, true, RequestPropertyBecameEnumCheck), + newBackwardCompatibilityRule(l, RequestPropertyBecameEnumId, ERR, true, RequestPropertyBecameEnumCheck), // RequestPropertyBecameNotNullableCheck - newBackwardCompatibilityRule(RequestBodyBecomeNotNullableId, ERR, true, RequestPropertyBecameNotNullableCheck), - newBackwardCompatibilityRule(RequestBodyBecomeNullableId, INFO, true, RequestPropertyBecameNotNullableCheck), - newBackwardCompatibilityRule(RequestPropertyBecomeNotNullableId, ERR, true, RequestPropertyBecameNotNullableCheck), - newBackwardCompatibilityRule(RequestPropertyBecomeNullableId, INFO, true, RequestPropertyBecameNotNullableCheck), + newBackwardCompatibilityRule(l, RequestBodyBecomeNotNullableId, ERR, true, RequestPropertyBecameNotNullableCheck), + newBackwardCompatibilityRule(l, RequestBodyBecomeNullableId, INFO, true, RequestPropertyBecameNotNullableCheck), + newBackwardCompatibilityRule(l, RequestPropertyBecomeNotNullableId, ERR, true, RequestPropertyBecameNotNullableCheck), + newBackwardCompatibilityRule(l, RequestPropertyBecomeNullableId, INFO, true, RequestPropertyBecameNotNullableCheck), // RequestPropertyDefaultValueChangedCheck - newBackwardCompatibilityRule(RequestBodyDefaultValueAddedId, INFO, true, RequestPropertyDefaultValueChangedCheck), - newBackwardCompatibilityRule(RequestBodyDefaultValueRemovedId, INFO, true, RequestPropertyDefaultValueChangedCheck), - newBackwardCompatibilityRule(RequestBodyDefaultValueChangedId, INFO, true, RequestPropertyDefaultValueChangedCheck), - newBackwardCompatibilityRule(RequestPropertyDefaultValueAddedId, INFO, true, RequestPropertyDefaultValueChangedCheck), - newBackwardCompatibilityRule(RequestPropertyDefaultValueRemovedId, INFO, true, RequestPropertyDefaultValueChangedCheck), - newBackwardCompatibilityRule(RequestPropertyDefaultValueChangedId, INFO, true, RequestPropertyDefaultValueChangedCheck), + newBackwardCompatibilityRule(l, RequestBodyDefaultValueAddedId, INFO, true, RequestPropertyDefaultValueChangedCheck), + newBackwardCompatibilityRule(l, RequestBodyDefaultValueRemovedId, INFO, true, RequestPropertyDefaultValueChangedCheck), + newBackwardCompatibilityRule(l, RequestBodyDefaultValueChangedId, INFO, true, RequestPropertyDefaultValueChangedCheck), + newBackwardCompatibilityRule(l, RequestPropertyDefaultValueAddedId, INFO, true, RequestPropertyDefaultValueChangedCheck), + newBackwardCompatibilityRule(l, RequestPropertyDefaultValueRemovedId, INFO, true, RequestPropertyDefaultValueChangedCheck), + newBackwardCompatibilityRule(l, RequestPropertyDefaultValueChangedId, INFO, true, RequestPropertyDefaultValueChangedCheck), // RequestPropertyEnumValueUpdatedCheck - newBackwardCompatibilityRule(RequestPropertyEnumValueRemovedId, ERR, true, RequestPropertyEnumValueUpdatedCheck), - newBackwardCompatibilityRule(RequestPropertyEnumValueAddedId, INFO, true, RequestPropertyEnumValueUpdatedCheck), + newBackwardCompatibilityRule(l, RequestPropertyEnumValueRemovedId, ERR, true, RequestPropertyEnumValueUpdatedCheck), + newBackwardCompatibilityRule(l, RequestPropertyEnumValueAddedId, INFO, true, RequestPropertyEnumValueUpdatedCheck), // RequestPropertyMaxDecreasedCheck - newBackwardCompatibilityRule(RequestBodyMaxDecreasedId, ERR, true, RequestPropertyMaxDecreasedCheck), - newBackwardCompatibilityRule(RequestBodyMaxIncreasedId, INFO, true, RequestPropertyMaxDecreasedCheck), - newBackwardCompatibilityRule(RequestPropertyMaxDecreasedId, ERR, true, RequestPropertyMaxDecreasedCheck), - newBackwardCompatibilityRule(RequestPropertyMaxIncreasedId, INFO, true, RequestPropertyMaxDecreasedCheck), + newBackwardCompatibilityRule(l, RequestBodyMaxDecreasedId, ERR, true, RequestPropertyMaxDecreasedCheck), + newBackwardCompatibilityRule(l, RequestBodyMaxIncreasedId, INFO, true, RequestPropertyMaxDecreasedCheck), + newBackwardCompatibilityRule(l, RequestPropertyMaxDecreasedId, ERR, true, RequestPropertyMaxDecreasedCheck), + newBackwardCompatibilityRule(l, RequestPropertyMaxIncreasedId, INFO, true, RequestPropertyMaxDecreasedCheck), // RequestPropertyMaxLengthSetCheck - newBackwardCompatibilityRule(RequestBodyMaxLengthSetId, WARN, true, RequestPropertyMaxLengthSetCheck), - newBackwardCompatibilityRule(RequestPropertyMaxLengthSetId, WARN, true, RequestPropertyMaxLengthSetCheck), + newBackwardCompatibilityRule(l, RequestBodyMaxLengthSetId, WARN, true, RequestPropertyMaxLengthSetCheck), + newBackwardCompatibilityRule(l, RequestPropertyMaxLengthSetId, WARN, true, RequestPropertyMaxLengthSetCheck), // RequestPropertyMaxLengthUpdatedCheck - newBackwardCompatibilityRule(RequestBodyMaxLengthDecreasedId, ERR, true, RequestPropertyMaxLengthUpdatedCheck), - newBackwardCompatibilityRule(RequestBodyMaxLengthIncreasedId, INFO, true, RequestPropertyMaxLengthUpdatedCheck), - newBackwardCompatibilityRule(RequestPropertyMaxLengthDecreasedId, ERR, true, RequestPropertyMaxLengthUpdatedCheck), - newBackwardCompatibilityRule(RequestPropertyMaxLengthIncreasedId, INFO, true, RequestPropertyMaxLengthUpdatedCheck), + newBackwardCompatibilityRule(l, RequestBodyMaxLengthDecreasedId, ERR, true, RequestPropertyMaxLengthUpdatedCheck), + newBackwardCompatibilityRule(l, RequestBodyMaxLengthIncreasedId, INFO, true, RequestPropertyMaxLengthUpdatedCheck), + newBackwardCompatibilityRule(l, RequestPropertyMaxLengthDecreasedId, ERR, true, RequestPropertyMaxLengthUpdatedCheck), + newBackwardCompatibilityRule(l, RequestPropertyMaxLengthIncreasedId, INFO, true, RequestPropertyMaxLengthUpdatedCheck), // RequestPropertyMaxSetCheck - newBackwardCompatibilityRule(RequestBodyMaxSetId, WARN, true, RequestPropertyMaxSetCheck), - newBackwardCompatibilityRule(RequestPropertyMaxSetId, WARN, true, RequestPropertyMaxSetCheck), + newBackwardCompatibilityRule(l, RequestBodyMaxSetId, WARN, true, RequestPropertyMaxSetCheck), + newBackwardCompatibilityRule(l, RequestPropertyMaxSetId, WARN, true, RequestPropertyMaxSetCheck), // RequestPropertyMinIncreasedCheck - newBackwardCompatibilityRule(RequestBodyMinIncreasedId, ERR, true, RequestPropertyMinIncreasedCheck), - newBackwardCompatibilityRule(RequestBodyMinDecreasedId, INFO, true, RequestPropertyMinIncreasedCheck), - newBackwardCompatibilityRule(RequestPropertyMinIncreasedId, ERR, true, RequestPropertyMinIncreasedCheck), - newBackwardCompatibilityRule(RequestPropertyMinDecreasedId, INFO, true, RequestPropertyMinIncreasedCheck), + newBackwardCompatibilityRule(l, RequestBodyMinIncreasedId, ERR, true, RequestPropertyMinIncreasedCheck), + newBackwardCompatibilityRule(l, RequestBodyMinDecreasedId, INFO, true, RequestPropertyMinIncreasedCheck), + newBackwardCompatibilityRule(l, RequestPropertyMinIncreasedId, ERR, true, RequestPropertyMinIncreasedCheck), + newBackwardCompatibilityRule(l, RequestPropertyMinDecreasedId, INFO, true, RequestPropertyMinIncreasedCheck), // RequestPropertyMinItemsIncreasedCheck - newBackwardCompatibilityRule(RequestBodyMinItemsIncreasedId, ERR, true, RequestPropertyMinItemsIncreasedCheck), - newBackwardCompatibilityRule(RequestPropertyMinItemsIncreasedId, ERR, true, RequestPropertyMinItemsIncreasedCheck), + newBackwardCompatibilityRule(l, RequestBodyMinItemsIncreasedId, ERR, true, RequestPropertyMinItemsIncreasedCheck), + newBackwardCompatibilityRule(l, RequestPropertyMinItemsIncreasedId, ERR, true, RequestPropertyMinItemsIncreasedCheck), // RequestPropertyMinItemsSetCheck - newBackwardCompatibilityRule(RequestBodyMinItemsSetId, WARN, true, RequestPropertyMinItemsSetCheck), - newBackwardCompatibilityRule(RequestPropertyMinItemsSetId, WARN, true, RequestPropertyMinItemsSetCheck), + newBackwardCompatibilityRule(l, RequestBodyMinItemsSetId, WARN, true, RequestPropertyMinItemsSetCheck), + newBackwardCompatibilityRule(l, RequestPropertyMinItemsSetId, WARN, true, RequestPropertyMinItemsSetCheck), // RequestPropertyMinLengthUpdatedCheck - newBackwardCompatibilityRule(RequestBodyMinLengthIncreasedId, ERR, true, RequestPropertyMinLengthUpdatedCheck), - newBackwardCompatibilityRule(RequestBodyMinLengthDecreasedId, INFO, true, RequestPropertyMinLengthUpdatedCheck), - newBackwardCompatibilityRule(RequestPropertyMinLengthIncreasedId, ERR, true, RequestPropertyMinLengthUpdatedCheck), - newBackwardCompatibilityRule(RequestPropertyMinLengthDecreasedId, INFO, true, RequestPropertyMinLengthUpdatedCheck), + newBackwardCompatibilityRule(l, RequestBodyMinLengthIncreasedId, ERR, true, RequestPropertyMinLengthUpdatedCheck), + newBackwardCompatibilityRule(l, RequestBodyMinLengthDecreasedId, INFO, true, RequestPropertyMinLengthUpdatedCheck), + newBackwardCompatibilityRule(l, RequestPropertyMinLengthIncreasedId, ERR, true, RequestPropertyMinLengthUpdatedCheck), + newBackwardCompatibilityRule(l, RequestPropertyMinLengthDecreasedId, INFO, true, RequestPropertyMinLengthUpdatedCheck), // RequestPropertyMinSetCheck - newBackwardCompatibilityRule(RequestBodyMinSetId, WARN, true, RequestPropertyMinSetCheck), - newBackwardCompatibilityRule(RequestPropertyMinSetId, WARN, true, RequestPropertyMinSetCheck), + newBackwardCompatibilityRule(l, RequestBodyMinSetId, WARN, true, RequestPropertyMinSetCheck), + newBackwardCompatibilityRule(l, RequestPropertyMinSetId, WARN, true, RequestPropertyMinSetCheck), // RequestPropertyOneOfUpdatedCheck - newBackwardCompatibilityRule(RequestBodyOneOfAddedId, INFO, true, RequestPropertyOneOfUpdatedCheck), - newBackwardCompatibilityRule(RequestBodyOneOfRemovedId, ERR, true, RequestPropertyOneOfUpdatedCheck), - newBackwardCompatibilityRule(RequestPropertyOneOfAddedId, INFO, true, RequestPropertyOneOfUpdatedCheck), - newBackwardCompatibilityRule(RequestPropertyOneOfRemovedId, ERR, true, RequestPropertyOneOfUpdatedCheck), + newBackwardCompatibilityRule(l, RequestBodyOneOfAddedId, INFO, true, RequestPropertyOneOfUpdatedCheck), + newBackwardCompatibilityRule(l, RequestBodyOneOfRemovedId, ERR, true, RequestPropertyOneOfUpdatedCheck), + newBackwardCompatibilityRule(l, RequestPropertyOneOfAddedId, INFO, true, RequestPropertyOneOfUpdatedCheck), + newBackwardCompatibilityRule(l, RequestPropertyOneOfRemovedId, ERR, true, RequestPropertyOneOfUpdatedCheck), // RequestPropertyPatternUpdatedCheck - newBackwardCompatibilityRule(RequestPropertyPatternRemovedId, INFO, true, RequestPropertyPatternUpdatedCheck), - newBackwardCompatibilityRule(RequestPropertyPatternAddedId, WARN, true, RequestPropertyPatternUpdatedCheck), - newBackwardCompatibilityRule(RequestPropertyPatternChangedId, WARN, true, RequestPropertyPatternUpdatedCheck), + newBackwardCompatibilityRule(l, RequestPropertyPatternRemovedId, INFO, true, RequestPropertyPatternUpdatedCheck), + newBackwardCompatibilityRule(l, RequestPropertyPatternAddedId, WARN, true, RequestPropertyPatternUpdatedCheck), + newBackwardCompatibilityRule(l, RequestPropertyPatternChangedId, WARN, true, RequestPropertyPatternUpdatedCheck), // RequestPropertyRequiredUpdatedCheck - newBackwardCompatibilityRule(RequestPropertyBecameRequiredId, ERR, true, RequestPropertyRequiredUpdatedCheck), - newBackwardCompatibilityRule(RequestPropertyBecameOptionalId, INFO, true, RequestPropertyRequiredUpdatedCheck), + newBackwardCompatibilityRule(l, RequestPropertyBecameRequiredId, ERR, true, RequestPropertyRequiredUpdatedCheck), + newBackwardCompatibilityRule(l, RequestPropertyBecameOptionalId, INFO, true, RequestPropertyRequiredUpdatedCheck), // RequestPropertyTypeChangedCheck - newBackwardCompatibilityRule(RequestBodyTypeChangedId, ERR, true, RequestPropertyTypeChangedCheck), - newBackwardCompatibilityRule(RequestPropertyTypeChangedId, INFO, true, RequestPropertyTypeChangedCheck), + newBackwardCompatibilityRule(l, RequestBodyTypeChangedId, ERR, true, RequestPropertyTypeChangedCheck), + newBackwardCompatibilityRule(l, RequestPropertyTypeChangedId, INFO, true, RequestPropertyTypeChangedCheck), // RequestPropertyUpdatedCheck - newBackwardCompatibilityRule(RequestPropertyRemovedId, WARN, true, RequestPropertyUpdatedCheck), - newBackwardCompatibilityRule(NewRequiredRequestPropertyId, ERR, true, RequestPropertyUpdatedCheck), - newBackwardCompatibilityRule(NewOptionalRequestPropertyId, INFO, true, RequestPropertyUpdatedCheck), + newBackwardCompatibilityRule(l, RequestPropertyRemovedId, WARN, true, RequestPropertyUpdatedCheck), + newBackwardCompatibilityRule(l, NewRequiredRequestPropertyId, ERR, true, RequestPropertyUpdatedCheck), + newBackwardCompatibilityRule(l, NewOptionalRequestPropertyId, INFO, true, RequestPropertyUpdatedCheck), // RequestPropertyWriteOnlyReadOnlyCheck - newBackwardCompatibilityRule(RequestOptionalPropertyBecameNonWriteOnlyCheckId, INFO, true, RequestPropertyWriteOnlyReadOnlyCheck), - newBackwardCompatibilityRule(RequestOptionalPropertyBecameWriteOnlyCheckId, INFO, true, RequestPropertyWriteOnlyReadOnlyCheck), - newBackwardCompatibilityRule(RequestOptionalPropertyBecameReadOnlyCheckId, INFO, true, RequestPropertyWriteOnlyReadOnlyCheck), - newBackwardCompatibilityRule(RequestOptionalPropertyBecameNonReadOnlyCheckId, INFO, true, RequestPropertyWriteOnlyReadOnlyCheck), - newBackwardCompatibilityRule(RequestRequiredPropertyBecameNonWriteOnlyCheckId, INFO, true, RequestPropertyWriteOnlyReadOnlyCheck), - newBackwardCompatibilityRule(RequestRequiredPropertyBecameWriteOnlyCheckId, INFO, true, RequestPropertyWriteOnlyReadOnlyCheck), - newBackwardCompatibilityRule(RequestRequiredPropertyBecameReadOnlyCheckId, INFO, true, RequestPropertyWriteOnlyReadOnlyCheck), - newBackwardCompatibilityRule(RequestRequiredPropertyBecameNonReadOnlyCheckId, INFO, true, RequestPropertyWriteOnlyReadOnlyCheck), + newBackwardCompatibilityRule(l, RequestOptionalPropertyBecameNonWriteOnlyCheckId, INFO, true, RequestPropertyWriteOnlyReadOnlyCheck), + newBackwardCompatibilityRule(l, RequestOptionalPropertyBecameWriteOnlyCheckId, INFO, true, RequestPropertyWriteOnlyReadOnlyCheck), + newBackwardCompatibilityRule(l, RequestOptionalPropertyBecameReadOnlyCheckId, INFO, true, RequestPropertyWriteOnlyReadOnlyCheck), + newBackwardCompatibilityRule(l, RequestOptionalPropertyBecameNonReadOnlyCheckId, INFO, true, RequestPropertyWriteOnlyReadOnlyCheck), + newBackwardCompatibilityRule(l, RequestRequiredPropertyBecameNonWriteOnlyCheckId, INFO, true, RequestPropertyWriteOnlyReadOnlyCheck), + newBackwardCompatibilityRule(l, RequestRequiredPropertyBecameWriteOnlyCheckId, INFO, true, RequestPropertyWriteOnlyReadOnlyCheck), + newBackwardCompatibilityRule(l, RequestRequiredPropertyBecameReadOnlyCheckId, INFO, true, RequestPropertyWriteOnlyReadOnlyCheck), + newBackwardCompatibilityRule(l, RequestRequiredPropertyBecameNonReadOnlyCheckId, INFO, true, RequestPropertyWriteOnlyReadOnlyCheck), // RequestPropertyXExtensibleEnumValueRemovedCheck - newBackwardCompatibilityRule(UnparseablePropertyFromXExtensibleEnumId, ERR, true, RequestPropertyXExtensibleEnumValueRemovedCheck), - newBackwardCompatibilityRule(UnparseablePropertyToXExtensibleEnumId, ERR, true, RequestPropertyXExtensibleEnumValueRemovedCheck), - newBackwardCompatibilityRule(RequestPropertyXExtensibleEnumValueRemovedId, ERR, true, RequestPropertyXExtensibleEnumValueRemovedCheck), + newBackwardCompatibilityRule(l, UnparseablePropertyFromXExtensibleEnumId, ERR, true, RequestPropertyXExtensibleEnumValueRemovedCheck), + newBackwardCompatibilityRule(l, UnparseablePropertyToXExtensibleEnumId, ERR, true, RequestPropertyXExtensibleEnumValueRemovedCheck), + newBackwardCompatibilityRule(l, RequestPropertyXExtensibleEnumValueRemovedId, ERR, true, RequestPropertyXExtensibleEnumValueRemovedCheck), // ResponseDiscriminatorUpdatedCheck - newBackwardCompatibilityRule(ResponseBodyDiscriminatorAddedId, INFO, true, ResponseDiscriminatorUpdatedCheck), - newBackwardCompatibilityRule(ResponseBodyDiscriminatorRemovedId, INFO, true, ResponseDiscriminatorUpdatedCheck), - newBackwardCompatibilityRule(ResponseBodyDiscriminatorPropertyNameChangedId, INFO, true, ResponseDiscriminatorUpdatedCheck), - newBackwardCompatibilityRule(ResponseBodyDiscriminatorMappingAddedId, INFO, true, ResponseDiscriminatorUpdatedCheck), - newBackwardCompatibilityRule(ResponseBodyDiscriminatorMappingDeletedId, INFO, true, ResponseDiscriminatorUpdatedCheck), - newBackwardCompatibilityRule(ResponseBodyDiscriminatorMappingChangedId, INFO, true, ResponseDiscriminatorUpdatedCheck), - newBackwardCompatibilityRule(ResponsePropertyDiscriminatorAddedId, INFO, true, ResponseDiscriminatorUpdatedCheck), - newBackwardCompatibilityRule(ResponsePropertyDiscriminatorRemovedId, INFO, true, ResponseDiscriminatorUpdatedCheck), - newBackwardCompatibilityRule(ResponsePropertyDiscriminatorPropertyNameChangedId, INFO, true, ResponseDiscriminatorUpdatedCheck), - newBackwardCompatibilityRule(ResponsePropertyDiscriminatorMappingAddedId, INFO, true, ResponseDiscriminatorUpdatedCheck), - newBackwardCompatibilityRule(ResponsePropertyDiscriminatorMappingDeletedId, INFO, true, ResponseDiscriminatorUpdatedCheck), - newBackwardCompatibilityRule(ResponsePropertyDiscriminatorMappingChangedId, INFO, true, ResponseDiscriminatorUpdatedCheck), + newBackwardCompatibilityRule(l, ResponseBodyDiscriminatorAddedId, INFO, true, ResponseDiscriminatorUpdatedCheck), + newBackwardCompatibilityRule(l, ResponseBodyDiscriminatorRemovedId, INFO, true, ResponseDiscriminatorUpdatedCheck), + newBackwardCompatibilityRule(l, ResponseBodyDiscriminatorPropertyNameChangedId, INFO, true, ResponseDiscriminatorUpdatedCheck), + newBackwardCompatibilityRule(l, ResponseBodyDiscriminatorMappingAddedId, INFO, true, ResponseDiscriminatorUpdatedCheck), + newBackwardCompatibilityRule(l, ResponseBodyDiscriminatorMappingDeletedId, INFO, true, ResponseDiscriminatorUpdatedCheck), + newBackwardCompatibilityRule(l, ResponseBodyDiscriminatorMappingChangedId, INFO, true, ResponseDiscriminatorUpdatedCheck), + newBackwardCompatibilityRule(l, ResponsePropertyDiscriminatorAddedId, INFO, true, ResponseDiscriminatorUpdatedCheck), + newBackwardCompatibilityRule(l, ResponsePropertyDiscriminatorRemovedId, INFO, true, ResponseDiscriminatorUpdatedCheck), + newBackwardCompatibilityRule(l, ResponsePropertyDiscriminatorPropertyNameChangedId, INFO, true, ResponseDiscriminatorUpdatedCheck), + newBackwardCompatibilityRule(l, ResponsePropertyDiscriminatorMappingAddedId, INFO, true, ResponseDiscriminatorUpdatedCheck), + newBackwardCompatibilityRule(l, ResponsePropertyDiscriminatorMappingDeletedId, INFO, true, ResponseDiscriminatorUpdatedCheck), + newBackwardCompatibilityRule(l, ResponsePropertyDiscriminatorMappingChangedId, INFO, true, ResponseDiscriminatorUpdatedCheck), // ResponseHeaderBecameOptionalCheck - newBackwardCompatibilityRule(ResponseHeaderBecameOptionalId, ERR, true, ResponseHeaderBecameOptionalCheck), + newBackwardCompatibilityRule(l, ResponseHeaderBecameOptionalId, ERR, true, ResponseHeaderBecameOptionalCheck), // ResponseHeaderRemovedCheck - newBackwardCompatibilityRule(RequiredResponseHeaderRemovedId, ERR, true, ResponseHeaderRemovedCheck), - newBackwardCompatibilityRule(OptionalResponseHeaderRemovedId, WARN, true, ResponseHeaderRemovedCheck), + newBackwardCompatibilityRule(l, RequiredResponseHeaderRemovedId, ERR, true, ResponseHeaderRemovedCheck), + newBackwardCompatibilityRule(l, OptionalResponseHeaderRemovedId, WARN, true, ResponseHeaderRemovedCheck), // ResponseMediaTypeUpdatedCheck - newBackwardCompatibilityRule(ResponseMediaTypeUpdatedId, ERR, true, ResponseMediaTypeUpdatedCheck), - newBackwardCompatibilityRule(ResponseMediaTypeAddedId, INFO, true, ResponseMediaTypeUpdatedCheck), + newBackwardCompatibilityRule(l, ResponseMediaTypeUpdatedId, ERR, true, ResponseMediaTypeUpdatedCheck), + newBackwardCompatibilityRule(l, ResponseMediaTypeAddedId, INFO, true, ResponseMediaTypeUpdatedCheck), // ResponseOptionalPropertyUpdatedCheck - newBackwardCompatibilityRule(ResponseOptionalPropertyRemovedId, WARN, true, ResponseOptionalPropertyUpdatedCheck), - newBackwardCompatibilityRule(ResponseOptionalWriteOnlyPropertyRemovedId, INFO, true, ResponseOptionalPropertyUpdatedCheck), - newBackwardCompatibilityRule(ResponseOptionalPropertyAddedId, INFO, true, ResponseOptionalPropertyUpdatedCheck), - newBackwardCompatibilityRule(ResponseOptionalWriteOnlyPropertyAddedId, INFO, true, ResponseOptionalPropertyUpdatedCheck), + newBackwardCompatibilityRule(l, ResponseOptionalPropertyRemovedId, WARN, true, ResponseOptionalPropertyUpdatedCheck), + newBackwardCompatibilityRule(l, ResponseOptionalWriteOnlyPropertyRemovedId, INFO, true, ResponseOptionalPropertyUpdatedCheck), + newBackwardCompatibilityRule(l, ResponseOptionalPropertyAddedId, INFO, true, ResponseOptionalPropertyUpdatedCheck), + newBackwardCompatibilityRule(l, ResponseOptionalWriteOnlyPropertyAddedId, INFO, true, ResponseOptionalPropertyUpdatedCheck), // ResponseOptionalPropertyWriteOnlyReadOnlyCheck - newBackwardCompatibilityRule(ResponseOptionalPropertyBecameNonWriteOnlyId, INFO, true, ResponseOptionalPropertyWriteOnlyReadOnlyCheck), - newBackwardCompatibilityRule(ResponseOptionalPropertyBecameWriteOnlyId, INFO, true, ResponseOptionalPropertyWriteOnlyReadOnlyCheck), - newBackwardCompatibilityRule(ResponseOptionalPropertyBecameReadOnlyId, INFO, true, ResponseOptionalPropertyWriteOnlyReadOnlyCheck), - newBackwardCompatibilityRule(ResponseOptionalPropertyBecameNonReadOnlyId, INFO, true, ResponseOptionalPropertyWriteOnlyReadOnlyCheck), + newBackwardCompatibilityRule(l, ResponseOptionalPropertyBecameNonWriteOnlyId, INFO, true, ResponseOptionalPropertyWriteOnlyReadOnlyCheck), + newBackwardCompatibilityRule(l, ResponseOptionalPropertyBecameWriteOnlyId, INFO, true, ResponseOptionalPropertyWriteOnlyReadOnlyCheck), + newBackwardCompatibilityRule(l, ResponseOptionalPropertyBecameReadOnlyId, INFO, true, ResponseOptionalPropertyWriteOnlyReadOnlyCheck), + newBackwardCompatibilityRule(l, ResponseOptionalPropertyBecameNonReadOnlyId, INFO, true, ResponseOptionalPropertyWriteOnlyReadOnlyCheck), // ResponsePatternAddedOrChangedCheck - newBackwardCompatibilityRule(ResponsePropertyPatternAddedId, INFO, true, ResponsePatternAddedOrChangedCheck), - newBackwardCompatibilityRule(ResponsePropertyPatternChangedId, INFO, true, ResponsePatternAddedOrChangedCheck), - newBackwardCompatibilityRule(ResponsePropertyPatternRemovedId, INFO, true, ResponsePatternAddedOrChangedCheck), + newBackwardCompatibilityRule(l, ResponsePropertyPatternAddedId, INFO, true, ResponsePatternAddedOrChangedCheck), + newBackwardCompatibilityRule(l, ResponsePropertyPatternChangedId, INFO, true, ResponsePatternAddedOrChangedCheck), + newBackwardCompatibilityRule(l, ResponsePropertyPatternRemovedId, INFO, true, ResponsePatternAddedOrChangedCheck), // ResponsePropertyAllOfUpdatedCheck - newBackwardCompatibilityRule(ResponseBodyAllOfAddedId, INFO, true, ResponsePropertyAllOfUpdatedCheck), - newBackwardCompatibilityRule(ResponseBodyAllOfRemovedId, INFO, true, ResponsePropertyAllOfUpdatedCheck), - newBackwardCompatibilityRule(ResponsePropertyAllOfAddedId, INFO, true, ResponsePropertyAllOfUpdatedCheck), - newBackwardCompatibilityRule(ResponsePropertyAllOfRemovedId, INFO, true, ResponsePropertyAllOfUpdatedCheck), + newBackwardCompatibilityRule(l, ResponseBodyAllOfAddedId, INFO, true, ResponsePropertyAllOfUpdatedCheck), + newBackwardCompatibilityRule(l, ResponseBodyAllOfRemovedId, INFO, true, ResponsePropertyAllOfUpdatedCheck), + newBackwardCompatibilityRule(l, ResponsePropertyAllOfAddedId, INFO, true, ResponsePropertyAllOfUpdatedCheck), + newBackwardCompatibilityRule(l, ResponsePropertyAllOfRemovedId, INFO, true, ResponsePropertyAllOfUpdatedCheck), // ResponsePropertyAnyOfUpdatedCheck - newBackwardCompatibilityRule(ResponseBodyAnyOfAddedId, INFO, true, ResponsePropertyAnyOfUpdatedCheck), - newBackwardCompatibilityRule(ResponseBodyAnyOfRemovedId, INFO, true, ResponsePropertyAnyOfUpdatedCheck), - newBackwardCompatibilityRule(ResponsePropertyAnyOfAddedId, INFO, true, ResponsePropertyAnyOfUpdatedCheck), - newBackwardCompatibilityRule(ResponsePropertyAnyOfRemovedId, INFO, true, ResponsePropertyAnyOfUpdatedCheck), + newBackwardCompatibilityRule(l, ResponseBodyAnyOfAddedId, INFO, true, ResponsePropertyAnyOfUpdatedCheck), + newBackwardCompatibilityRule(l, ResponseBodyAnyOfRemovedId, INFO, true, ResponsePropertyAnyOfUpdatedCheck), + newBackwardCompatibilityRule(l, ResponsePropertyAnyOfAddedId, INFO, true, ResponsePropertyAnyOfUpdatedCheck), + newBackwardCompatibilityRule(l, ResponsePropertyAnyOfRemovedId, INFO, true, ResponsePropertyAnyOfUpdatedCheck), // ResponsePropertyBecameNullableCheck - newBackwardCompatibilityRule(ResponsePropertyBecameNullableId, ERR, true, ResponsePropertyBecameNullableCheck), - newBackwardCompatibilityRule(ResponseBodyBecameNullableId, ERR, true, ResponsePropertyBecameNullableCheck), + newBackwardCompatibilityRule(l, ResponsePropertyBecameNullableId, ERR, true, ResponsePropertyBecameNullableCheck), + newBackwardCompatibilityRule(l, ResponseBodyBecameNullableId, ERR, true, ResponsePropertyBecameNullableCheck), // ResponsePropertyBecameOptionalCheck - newBackwardCompatibilityRule(ResponsePropertyBecameOptionalId, ERR, true, ResponsePropertyBecameOptionalCheck), - newBackwardCompatibilityRule(ResponseWriteOnlyPropertyBecameOptionalId, ERR, true, ResponsePropertyBecameOptionalCheck), + newBackwardCompatibilityRule(l, ResponsePropertyBecameOptionalId, ERR, true, ResponsePropertyBecameOptionalCheck), + newBackwardCompatibilityRule(l, ResponseWriteOnlyPropertyBecameOptionalId, ERR, true, ResponsePropertyBecameOptionalCheck), // ResponsePropertyBecameRequiredCheck - newBackwardCompatibilityRule(ResponsePropertyBecameRequiredId, INFO, true, ResponsePropertyBecameRequiredCheck), - newBackwardCompatibilityRule(ResponseWriteOnlyPropertyBecameRequiredId, INFO, true, ResponsePropertyBecameRequiredCheck), + newBackwardCompatibilityRule(l, ResponsePropertyBecameRequiredId, INFO, true, ResponsePropertyBecameRequiredCheck), + newBackwardCompatibilityRule(l, ResponseWriteOnlyPropertyBecameRequiredId, INFO, true, ResponsePropertyBecameRequiredCheck), // ResponsePropertyDefaultValueChangedCheck - newBackwardCompatibilityRule(ResponseBodyDefaultValueAddedId, INFO, true, ResponsePropertyDefaultValueChangedCheck), - newBackwardCompatibilityRule(ResponseBodyDefaultValueRemovedId, INFO, true, ResponsePropertyDefaultValueChangedCheck), - newBackwardCompatibilityRule(ResponseBodyDefaultValueChangedId, INFO, true, ResponsePropertyDefaultValueChangedCheck), - newBackwardCompatibilityRule(ResponsePropertyDefaultValueAddedId, INFO, true, ResponsePropertyDefaultValueChangedCheck), - newBackwardCompatibilityRule(ResponsePropertyDefaultValueRemovedId, INFO, true, ResponsePropertyDefaultValueChangedCheck), - newBackwardCompatibilityRule(ResponsePropertyDefaultValueChangedId, INFO, true, ResponsePropertyDefaultValueChangedCheck), + newBackwardCompatibilityRule(l, ResponseBodyDefaultValueAddedId, INFO, true, ResponsePropertyDefaultValueChangedCheck), + newBackwardCompatibilityRule(l, ResponseBodyDefaultValueRemovedId, INFO, true, ResponsePropertyDefaultValueChangedCheck), + newBackwardCompatibilityRule(l, ResponseBodyDefaultValueChangedId, INFO, true, ResponsePropertyDefaultValueChangedCheck), + newBackwardCompatibilityRule(l, ResponsePropertyDefaultValueAddedId, INFO, true, ResponsePropertyDefaultValueChangedCheck), + newBackwardCompatibilityRule(l, ResponsePropertyDefaultValueRemovedId, INFO, true, ResponsePropertyDefaultValueChangedCheck), + newBackwardCompatibilityRule(l, ResponsePropertyDefaultValueChangedId, INFO, true, ResponsePropertyDefaultValueChangedCheck), // ResponsePropertyEnumValueAddedCheck - newBackwardCompatibilityRule(ResponsePropertyEnumValueAddedId, WARN, true, ResponsePropertyEnumValueAddedCheck), - newBackwardCompatibilityRule(ResponseWriteOnlyPropertyEnumValueAddedId, INFO, true, ResponsePropertyEnumValueAddedCheck), + newBackwardCompatibilityRule(l, ResponsePropertyEnumValueAddedId, WARN, true, ResponsePropertyEnumValueAddedCheck), + newBackwardCompatibilityRule(l, ResponseWriteOnlyPropertyEnumValueAddedId, INFO, true, ResponsePropertyEnumValueAddedCheck), // ResponsePropertyMaxIncreasedCheck - newBackwardCompatibilityRule(ResponseBodyMaxIncreasedId, ERR, true, ResponsePropertyMaxIncreasedCheck), - newBackwardCompatibilityRule(ResponsePropertyMaxIncreasedId, ERR, true, ResponsePropertyMaxIncreasedCheck), + newBackwardCompatibilityRule(l, ResponseBodyMaxIncreasedId, ERR, true, ResponsePropertyMaxIncreasedCheck), + newBackwardCompatibilityRule(l, ResponsePropertyMaxIncreasedId, ERR, true, ResponsePropertyMaxIncreasedCheck), // ResponsePropertyMaxLengthIncreasedCheck - newBackwardCompatibilityRule(ResponseBodyMaxLengthIncreasedId, ERR, true, ResponsePropertyMaxLengthIncreasedCheck), - newBackwardCompatibilityRule(ResponsePropertyMaxLengthIncreasedId, ERR, true, ResponsePropertyMaxLengthIncreasedCheck), + newBackwardCompatibilityRule(l, ResponseBodyMaxLengthIncreasedId, ERR, true, ResponsePropertyMaxLengthIncreasedCheck), + newBackwardCompatibilityRule(l, ResponsePropertyMaxLengthIncreasedId, ERR, true, ResponsePropertyMaxLengthIncreasedCheck), // ResponsePropertyMaxLengthUnsetCheck - newBackwardCompatibilityRule(ResponseBodyMaxLengthUnsetId, ERR, true, ResponsePropertyMaxLengthUnsetCheck), - newBackwardCompatibilityRule(ResponsePropertyMaxLengthUnsetId, ERR, true, ResponsePropertyMaxLengthUnsetCheck), + newBackwardCompatibilityRule(l, ResponseBodyMaxLengthUnsetId, ERR, true, ResponsePropertyMaxLengthUnsetCheck), + newBackwardCompatibilityRule(l, ResponsePropertyMaxLengthUnsetId, ERR, true, ResponsePropertyMaxLengthUnsetCheck), // ResponsePropertyMinDecreasedCheck - newBackwardCompatibilityRule(ResponseBodyMinDecreasedId, ERR, true, ResponsePropertyMinDecreasedCheck), - newBackwardCompatibilityRule(ResponsePropertyMinDecreasedId, ERR, true, ResponsePropertyMinDecreasedCheck), + newBackwardCompatibilityRule(l, ResponseBodyMinDecreasedId, ERR, true, ResponsePropertyMinDecreasedCheck), + newBackwardCompatibilityRule(l, ResponsePropertyMinDecreasedId, ERR, true, ResponsePropertyMinDecreasedCheck), // ResponsePropertyMinItemsDecreasedCheck - newBackwardCompatibilityRule(ResponseBodyMinItemsDecreasedId, ERR, true, ResponsePropertyMinItemsDecreasedCheck), - newBackwardCompatibilityRule(ResponsePropertyMinItemsDecreasedId, ERR, true, ResponsePropertyMinItemsDecreasedCheck), + newBackwardCompatibilityRule(l, ResponseBodyMinItemsDecreasedId, ERR, true, ResponsePropertyMinItemsDecreasedCheck), + newBackwardCompatibilityRule(l, ResponsePropertyMinItemsDecreasedId, ERR, true, ResponsePropertyMinItemsDecreasedCheck), // ResponsePropertyMinItemsUnsetCheck - newBackwardCompatibilityRule(ResponseBodyMinItemsUnsetId, ERR, true, ResponsePropertyMinItemsUnsetCheck), - newBackwardCompatibilityRule(ResponsePropertyMinItemsUnsetId, ERR, true, ResponsePropertyMinItemsUnsetCheck), + newBackwardCompatibilityRule(l, ResponseBodyMinItemsUnsetId, ERR, true, ResponsePropertyMinItemsUnsetCheck), + newBackwardCompatibilityRule(l, ResponsePropertyMinItemsUnsetId, ERR, true, ResponsePropertyMinItemsUnsetCheck), // ResponsePropertyMinLengthDecreasedCheck - newBackwardCompatibilityRule(ResponseBodyMinLengthDecreasedId, ERR, true, ResponsePropertyMinLengthDecreasedCheck), - newBackwardCompatibilityRule(ResponsePropertyMinLengthDecreasedId, ERR, true, ResponsePropertyMinLengthDecreasedCheck), + newBackwardCompatibilityRule(l, ResponseBodyMinLengthDecreasedId, ERR, true, ResponsePropertyMinLengthDecreasedCheck), + newBackwardCompatibilityRule(l, ResponsePropertyMinLengthDecreasedId, ERR, true, ResponsePropertyMinLengthDecreasedCheck), // ResponsePropertyOneOfUpdated - newBackwardCompatibilityRule(ResponseBodyOneOfAddedId, INFO, true, ResponsePropertyOneOfUpdated), - newBackwardCompatibilityRule(ResponseBodyOneOfRemovedId, INFO, true, ResponsePropertyOneOfUpdated), - newBackwardCompatibilityRule(ResponsePropertyOneOfAddedId, INFO, true, ResponsePropertyOneOfUpdated), - newBackwardCompatibilityRule(ResponsePropertyOneOfRemovedId, INFO, true, ResponsePropertyOneOfUpdated), + newBackwardCompatibilityRule(l, ResponseBodyOneOfAddedId, INFO, true, ResponsePropertyOneOfUpdated), + newBackwardCompatibilityRule(l, ResponseBodyOneOfRemovedId, INFO, true, ResponsePropertyOneOfUpdated), + newBackwardCompatibilityRule(l, ResponsePropertyOneOfAddedId, INFO, true, ResponsePropertyOneOfUpdated), + newBackwardCompatibilityRule(l, ResponsePropertyOneOfRemovedId, INFO, true, ResponsePropertyOneOfUpdated), // ResponsePropertyTypeChangedCheck - newBackwardCompatibilityRule(ResponseBodyTypeChangedId, ERR, true, ResponsePropertyTypeChangedCheck), - newBackwardCompatibilityRule(ResponsePropertyTypeChangedId, ERR, true, ResponsePropertyTypeChangedCheck), + newBackwardCompatibilityRule(l, ResponseBodyTypeChangedId, ERR, true, ResponsePropertyTypeChangedCheck), + newBackwardCompatibilityRule(l, ResponsePropertyTypeChangedId, ERR, true, ResponsePropertyTypeChangedCheck), // ResponseRequiredPropertyUpdatedCheck - newBackwardCompatibilityRule(ResponseRequiredPropertyRemovedId, ERR, true, ResponseRequiredPropertyUpdatedCheck), - newBackwardCompatibilityRule(ResponseRequiredWriteOnlyPropertyRemovedId, INFO, true, ResponseRequiredPropertyUpdatedCheck), - newBackwardCompatibilityRule(ResponseRequiredPropertyAddedId, ERR, true, ResponseRequiredPropertyUpdatedCheck), - newBackwardCompatibilityRule(ResponseRequiredWriteOnlyPropertyAddedId, INFO, true, ResponseRequiredPropertyUpdatedCheck), + newBackwardCompatibilityRule(l, ResponseRequiredPropertyRemovedId, ERR, true, ResponseRequiredPropertyUpdatedCheck), + newBackwardCompatibilityRule(l, ResponseRequiredWriteOnlyPropertyRemovedId, INFO, true, ResponseRequiredPropertyUpdatedCheck), + newBackwardCompatibilityRule(l, ResponseRequiredPropertyAddedId, ERR, true, ResponseRequiredPropertyUpdatedCheck), + newBackwardCompatibilityRule(l, ResponseRequiredWriteOnlyPropertyAddedId, INFO, true, ResponseRequiredPropertyUpdatedCheck), // ResponseRequiredPropertyWriteOnlyReadOnlyCheck - newBackwardCompatibilityRule(ResponseRequiredPropertyBecameNonWriteOnlyId, WARN, true, ResponseRequiredPropertyWriteOnlyReadOnlyCheck), - newBackwardCompatibilityRule(ResponseRequiredPropertyBecameWriteOnlyId, INFO, true, ResponseRequiredPropertyWriteOnlyReadOnlyCheck), - newBackwardCompatibilityRule(ResponseRequiredPropertyBecameReadOnlyId, INFO, true, ResponseRequiredPropertyWriteOnlyReadOnlyCheck), - newBackwardCompatibilityRule(ResponseRequiredPropertyBecameNonReadOnlyId, INFO, true, ResponseRequiredPropertyWriteOnlyReadOnlyCheck), + newBackwardCompatibilityRule(l, ResponseRequiredPropertyBecameNonWriteOnlyId, WARN, true, ResponseRequiredPropertyWriteOnlyReadOnlyCheck), + newBackwardCompatibilityRule(l, ResponseRequiredPropertyBecameWriteOnlyId, INFO, true, ResponseRequiredPropertyWriteOnlyReadOnlyCheck), + newBackwardCompatibilityRule(l, ResponseRequiredPropertyBecameReadOnlyId, INFO, true, ResponseRequiredPropertyWriteOnlyReadOnlyCheck), + newBackwardCompatibilityRule(l, ResponseRequiredPropertyBecameNonReadOnlyId, INFO, true, ResponseRequiredPropertyWriteOnlyReadOnlyCheck), // ResponseSuccessStatusUpdatedCheck - newBackwardCompatibilityRule(ResponseSuccessStatusRemovedId, ERR, true, ResponseSuccessStatusUpdatedCheck), - newBackwardCompatibilityRule(ResponseSuccessStatusAddedId, ERR, true, ResponseSuccessStatusUpdatedCheck), + newBackwardCompatibilityRule(l, ResponseSuccessStatusRemovedId, ERR, true, ResponseSuccessStatusUpdatedCheck), + newBackwardCompatibilityRule(l, ResponseSuccessStatusAddedId, ERR, true, ResponseSuccessStatusUpdatedCheck), // ResponseNonSuccessStatusUpdatedCheck - newBackwardCompatibilityRule(ResponseNonSuccessStatusRemovedId, ERR, false, ResponseNonSuccessStatusUpdatedCheck), - newBackwardCompatibilityRule(ResponseNonSuccessStatusAddedId, INFO, false, ResponseNonSuccessStatusUpdatedCheck), + newBackwardCompatibilityRule(l, ResponseNonSuccessStatusRemovedId, ERR, false, ResponseNonSuccessStatusUpdatedCheck), + newBackwardCompatibilityRule(l, ResponseNonSuccessStatusAddedId, INFO, false, ResponseNonSuccessStatusUpdatedCheck), // UncheckedRequestAllOfWarnCheck - newBackwardCompatibilityRule(RequestAllOfModifiedId, WARN, true, UncheckedRequestAllOfWarnCheck), + newBackwardCompatibilityRule(l, RequestAllOfModifiedId, WARN, true, UncheckedRequestAllOfWarnCheck), // UncheckedResponseAllOfWarnCheck - newBackwardCompatibilityRule(ResponseAllOfModifiedId, WARN, true, UncheckedResponseAllOfWarnCheck), + newBackwardCompatibilityRule(l, ResponseAllOfModifiedId, WARN, true, UncheckedResponseAllOfWarnCheck), // APIOperationIdUpdatedCheck - newBackwardCompatibilityRule(APIOperationIdRemovedId, ERR, false, APIOperationIdUpdatedCheck), - newBackwardCompatibilityRule(APIOperationIdAddId, INFO, false, APIOperationIdUpdatedCheck), + newBackwardCompatibilityRule(l, APIOperationIdRemovedId, ERR, false, APIOperationIdUpdatedCheck), + newBackwardCompatibilityRule(l, APIOperationIdAddId, INFO, false, APIOperationIdUpdatedCheck), // APITagUpdatedCheck - newBackwardCompatibilityRule(APITagRemovedId, ERR, false, APITagUpdatedCheck), - newBackwardCompatibilityRule(APITagAddedId, INFO, false, APITagUpdatedCheck), + newBackwardCompatibilityRule(l, APITagRemovedId, ERR, false, APITagUpdatedCheck), + newBackwardCompatibilityRule(l, APITagAddedId, INFO, false, APITagUpdatedCheck), // APIComponentsSchemaRemovedCheck - newBackwardCompatibilityRule(APISchemasRemovedId, ERR, false, APIComponentsSchemaRemovedCheck), + newBackwardCompatibilityRule(l, APISchemasRemovedId, ERR, false, APIComponentsSchemaRemovedCheck), // ResponseParameterEnumValueRemovedCheck - newBackwardCompatibilityRule(ResponsePropertyEnumValueRemovedId, ERR, false, ResponseParameterEnumValueRemovedCheck), + newBackwardCompatibilityRule(l, ResponsePropertyEnumValueRemovedId, ERR, false, ResponseParameterEnumValueRemovedCheck), // ResponseMediaTypeEnumValueRemovedCheck - newBackwardCompatibilityRule(ResponseMediaTypeEnumValueRemovedId, ERR, false, ResponseMediaTypeEnumValueRemovedCheck), + newBackwardCompatibilityRule(l, ResponseMediaTypeEnumValueRemovedId, ERR, false, ResponseMediaTypeEnumValueRemovedCheck), // RequestBodyEnumValueRemovedCheck - newBackwardCompatibilityRule(RequestBodyEnumValueRemovedId, ERR, false, RequestBodyEnumValueRemovedCheck), + newBackwardCompatibilityRule(l, RequestBodyEnumValueRemovedId, ERR, false, RequestBodyEnumValueRemovedCheck), } } -func GetOptionalRules() []BackwardCompatibilityRule { +func GetOptionalRules(l Localizer) []BackwardCompatibilityRule { result := []BackwardCompatibilityRule{} - for _, rule := range GetAllRules() { + for _, rule := range GetAllRules(l) { if rule.Required { continue } @@ -376,10 +380,10 @@ func GetOptionalRules() []BackwardCompatibilityRule { return result } -func GetRequiredRules() []BackwardCompatibilityRule { +func GetRequiredRules(l Localizer) []BackwardCompatibilityRule { result := []BackwardCompatibilityRule{} - for _, rule := range GetAllRules() { + for _, rule := range GetAllRules(l) { if rule.Required { result = append(result, rule) } diff --git a/diff/example_test.go b/diff/example_test.go index 6d7dc96e..c587d010 100644 --- a/diff/example_test.go +++ b/diff/example_test.go @@ -89,7 +89,7 @@ func ExampleGetPathsDiff() { } c := checker.GetDefaultChecks() - c.Localize = checker.NewLocalizer("en", "en") + c.Localize = checker.NewDefaultLocalizer() errs := checker.CheckBackwardCompatibility(c, diffRes, operationsSources) // process configuration file for ignoring errors diff --git a/formatters/checks.go b/formatters/checks.go index 8817cd90..0e73a739 100644 --- a/formatters/checks.go +++ b/formatters/checks.go @@ -6,3 +6,17 @@ type Check struct { Description string `json:"description" yaml:"description"` Required bool `json:"reuired" yaml:"reuired"` } + +type Checks []Check + +func (checks Checks) Len() int { + return len(checks) +} + +func (checks Checks) Less(i, j int) bool { + return checks[i].Id < checks[j].Id +} + +func (checks Checks) Swap(i, j int) { + checks[i], checks[j] = checks[j], checks[i] +} diff --git a/formatters/format_html_test.go b/formatters/format_html_test.go index a14a1abf..06857c49 100644 --- a/formatters/format_html_test.go +++ b/formatters/format_html_test.go @@ -28,7 +28,7 @@ func TestHtmlFormatter_NotImplemented(t *testing.T) { _, err = formatter.RenderChangelog(checker.Changes{}, formatters.RenderOpts{}) assert.Error(t, err) - _, err = formatter.RenderChecks([]formatters.Check{}, formatters.RenderOpts{}) + _, err = formatter.RenderChecks(formatters.Checks{}, formatters.RenderOpts{}) assert.Error(t, err) _, err = formatter.RenderFlatten(nil, formatters.RenderOpts{}) diff --git a/formatters/format_json.go b/formatters/format_json.go index dacd20d5..abffaf2c 100644 --- a/formatters/format_json.go +++ b/formatters/format_json.go @@ -29,7 +29,7 @@ func (f JSONFormatter) RenderChangelog(changes checker.Changes, opts RenderOpts) return printJSON(changes) } -func (f JSONFormatter) RenderChecks(checks []Check, opts RenderOpts) ([]byte, error) { +func (f JSONFormatter) RenderChecks(checks Checks, opts RenderOpts) ([]byte, error) { return printJSON(checks) } diff --git a/formatters/format_json_test.go b/formatters/format_json_test.go index 896581ec..43333a08 100644 --- a/formatters/format_json_test.go +++ b/formatters/format_json_test.go @@ -43,7 +43,7 @@ func TestJsonFormatter_RenderChangelog(t *testing.T) { func TestJsonFormatter_RenderChecks(t *testing.T) { formatter := formatters.JSONFormatter{} - checks := []formatters.Check{ + checks := formatters.Checks{ { Id: "change_id", Level: "info", diff --git a/formatters/format_text.go b/formatters/format_text.go index cbe70ae7..ae48fedf 100644 --- a/formatters/format_text.go +++ b/formatters/format_text.go @@ -69,7 +69,7 @@ func (f TEXTFormatter) RenderChangelog(changes checker.Changes, opts RenderOpts) return result.Bytes(), nil } -func (f TEXTFormatter) RenderChecks(checks []Check, opts RenderOpts) ([]byte, error) { +func (f TEXTFormatter) RenderChecks(checks Checks, opts RenderOpts) ([]byte, error) { result := bytes.NewBuffer(nil) w := tabwriter.NewWriter(result, 1, 1, 1, ' ', 0) diff --git a/formatters/format_text_test.go b/formatters/format_text_test.go index 62569e65..c9125269 100644 --- a/formatters/format_text_test.go +++ b/formatters/format_text_test.go @@ -6,12 +6,13 @@ import ( "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" "github.com/tufin/oasdiff/checker" + "github.com/tufin/oasdiff/checker/localizations" "github.com/tufin/oasdiff/formatters" ) func TestTextFormatter_RenderBreakingChanges(t *testing.T) { formatter, err := formatters.Lookup("text", formatters.FormatterOpts{ - Language: formatters.LangDefault, + Language: localizations.LangDefault, }) require.NoError(t, err) @@ -30,7 +31,7 @@ func TestTextFormatter_RenderBreakingChanges(t *testing.T) { func TestTextFormatter_RenderChangelog(t *testing.T) { formatter, err := formatters.Lookup("text", formatters.FormatterOpts{ - Language: formatters.LangDefault, + Language: localizations.LangDefault, }) require.NoError(t, err) @@ -49,11 +50,11 @@ func TestTextFormatter_RenderChangelog(t *testing.T) { func TestTextFormatter_RenderChecks(t *testing.T) { formatter, err := formatters.Lookup("text", formatters.FormatterOpts{ - Language: formatters.LangDefault, + Language: localizations.LangDefault, }) require.NoError(t, err) - checks := []formatters.Check{ + checks := formatters.Checks{ { Id: "change_id", Level: "info", @@ -69,7 +70,7 @@ func TestTextFormatter_RenderChecks(t *testing.T) { func TestTextFormatter_RenderDiff(t *testing.T) { formatter, err := formatters.Lookup("text", formatters.FormatterOpts{ - Language: formatters.LangDefault, + Language: localizations.LangDefault, }) require.NoError(t, err) @@ -80,7 +81,7 @@ func TestTextFormatter_RenderDiff(t *testing.T) { func TestTextFormatter_NotImplemented(t *testing.T) { formatter, err := formatters.Lookup("text", formatters.FormatterOpts{ - Language: formatters.LangDefault, + Language: localizations.LangDefault, }) require.NoError(t, err) diff --git a/formatters/format_yaml.go b/formatters/format_yaml.go index 3652c2bb..759d4c2b 100644 --- a/formatters/format_yaml.go +++ b/formatters/format_yaml.go @@ -29,7 +29,7 @@ func (f YAMLFormatter) RenderChangelog(changes checker.Changes, opts RenderOpts) return printYAML(changes) } -func (f YAMLFormatter) RenderChecks(checks []Check, opts RenderOpts) ([]byte, error) { +func (f YAMLFormatter) RenderChecks(checks Checks, opts RenderOpts) ([]byte, error) { return printYAML(checks) } diff --git a/formatters/format_yaml_test.go b/formatters/format_yaml_test.go index 7ab6d8de..87eb4e9c 100644 --- a/formatters/format_yaml_test.go +++ b/formatters/format_yaml_test.go @@ -43,7 +43,7 @@ func TestYamlFormatter_RenderChangelog(t *testing.T) { func TestYamlFormatter_RenderChecks(t *testing.T) { formatter := formatters.YAMLFormatter{} - checks := []formatters.Check{ + checks := formatters.Checks{ { Id: "change_id", Level: "info", diff --git a/formatters/interface.go b/formatters/interface.go index 11b12d63..bbafd975 100644 --- a/formatters/interface.go +++ b/formatters/interface.go @@ -5,6 +5,7 @@ import ( "github.com/getkin/kin-openapi/openapi3" "github.com/tufin/oasdiff/checker" + "github.com/tufin/oasdiff/checker/localizations" "github.com/tufin/oasdiff/diff" "golang.org/x/exp/slices" ) @@ -15,7 +16,7 @@ type Formatter interface { RenderSummary(diff *diff.Diff, opts RenderOpts) ([]byte, error) RenderBreakingChanges(changes checker.Changes, opts RenderOpts) ([]byte, error) RenderChangelog(changes checker.Changes, opts RenderOpts) ([]byte, error) - RenderChecks(checks []Check, opts RenderOpts) ([]byte, error) + RenderChecks(checks Checks, opts RenderOpts) ([]byte, error) RenderFlatten(spec *openapi3.T, opts RenderOpts) ([]byte, error) SupportedOutputs() []Output } @@ -40,7 +41,7 @@ func Lookup(format string, opts FormatterOpts) (Formatter, error) { return JSONFormatter{}, nil case FormatText: return TEXTFormatter{ - Localizer: checker.NewLocalizer(opts.Language, LangDefault), + Localizer: checker.NewLocalizer(opts.Language), }, nil case FormatHTML: return HTMLFormatter{}, nil @@ -66,6 +67,6 @@ func SupportedFormatsByContentType(output Output) []string { // DefaultFormatterOpts returns the default formatter options (e.g. colors, CI mode, etc.) func DefaultFormatterOpts() FormatterOpts { return FormatterOpts{ - Language: LangDefault, + Language: localizations.LangDefault, } } diff --git a/formatters/not_implemented.go b/formatters/not_implemented.go index 1d11e3c1..dbbae084 100644 --- a/formatters/not_implemented.go +++ b/formatters/not_implemented.go @@ -26,7 +26,7 @@ func (f notImplementedFormatter) RenderChangelog(checker.Changes, RenderOpts) ([ return notImplemented() } -func (f notImplementedFormatter) RenderChecks([]Check, RenderOpts) ([]byte, error) { +func (f notImplementedFormatter) RenderChecks(Checks, RenderOpts) ([]byte, error) { return notImplemented() } diff --git a/formatters/types.go b/formatters/types.go index 211677be..194d6d1f 100644 --- a/formatters/types.go +++ b/formatters/types.go @@ -1,7 +1,5 @@ package formatters -const LangDefault = "en" - type Format string const ( diff --git a/internal/breaking_changes.go b/internal/breaking_changes.go index 0b3307ca..f399f0ee 100644 --- a/internal/breaking_changes.go +++ b/internal/breaking_changes.go @@ -6,6 +6,7 @@ import ( "github.com/spf13/cobra" "github.com/tufin/oasdiff/checker" + "github.com/tufin/oasdiff/checker/localizations" "github.com/tufin/oasdiff/diff" "github.com/tufin/oasdiff/formatters" ) @@ -35,7 +36,7 @@ func getBreakingChangesCmd() *cobra.Command { cmd.PersistentFlags().BoolVarP(&flags.includePathParams, "include-path-params", "", false, "include path parameter names in endpoint matching") cmd.PersistentFlags().BoolVarP(&flags.flatten, "flatten", "", false, "merge subschemas under allOf before diff") enumWithOptions(&cmd, newEnumValue([]string{LevelErr, LevelWarn}, "", &flags.failOn), "fail-on", "o", "exit with return code 1 when output includes errors with this level or higher") - enumWithOptions(&cmd, newEnumValue([]string{LangEn, LangRu}, LangDefault, &flags.lang), "lang", "l", "language for localized output") + enumWithOptions(&cmd, newEnumValue(localizations.GetSupportedLanguages(), localizations.LangDefault, &flags.lang), "lang", "l", "language for localized output") cmd.PersistentFlags().StringVarP(&flags.errIgnoreFile, "err-ignore", "", "", "configuration file for ignoring errors") cmd.PersistentFlags().StringVarP(&flags.warnIgnoreFile, "warn-ignore", "", "", "configuration file for ignoring warnings") cmd.PersistentFlags().VarP(newEnumSliceValue(checker.GetOptionalChecks(), nil, &flags.includeChecks), "include-checks", "i", "comma-separated list of optional checks (run 'oasdiff checks --required false' to see options)") diff --git a/internal/changelog.go b/internal/changelog.go index 5359f3c2..97f456c2 100644 --- a/internal/changelog.go +++ b/internal/changelog.go @@ -7,6 +7,7 @@ import ( "github.com/getkin/kin-openapi/openapi3" "github.com/spf13/cobra" "github.com/tufin/oasdiff/checker" + "github.com/tufin/oasdiff/checker/localizations" "github.com/tufin/oasdiff/diff" "github.com/tufin/oasdiff/formatters" ) @@ -35,7 +36,7 @@ func getChangelogCmd() *cobra.Command { cmd.PersistentFlags().StringVarP(&flags.stripPrefixRevision, "strip-prefix-revision", "", "", "strip this prefix from paths in revised-spec before comparison") cmd.PersistentFlags().BoolVarP(&flags.includePathParams, "include-path-params", "", false, "include path parameter names in endpoint matching") cmd.PersistentFlags().BoolVarP(&flags.flatten, "flatten", "", false, "merge subschemas under allOf before diff") - enumWithOptions(&cmd, newEnumValue([]string{LangEn, LangRu}, LangDefault, &flags.lang), "lang", "l", "language for localized output") + enumWithOptions(&cmd, newEnumValue(localizations.GetSupportedLanguages(), localizations.LangDefault, &flags.lang), "lang", "l", "language for localized output") cmd.PersistentFlags().StringVarP(&flags.errIgnoreFile, "err-ignore", "", "", "configuration file for ignoring errors") cmd.PersistentFlags().StringVarP(&flags.warnIgnoreFile, "warn-ignore", "", "", "configuration file for ignoring warnings") cmd.PersistentFlags().VarP(newEnumSliceValue(checker.GetOptionalChecks(), nil, &flags.includeChecks), "include-checks", "i", "comma-separated list of optional checks (run 'oasdiff checks --required false' to see options)") @@ -63,7 +64,7 @@ func getChangelog(flags Flags, stdout io.Writer, level checker.Level) (bool, *Re } bcConfig := checker.GetAllChecks(flags.getIncludeChecks(), flags.getDeprecationDaysBeta(), flags.getDeprecationDaysStable()) - bcConfig.Localize = checker.NewLocalizer(flags.getLang(), LangDefault) + bcConfig.Localize = checker.NewLocalizer(flags.getLang()) errs, returnErr := filterIgnored( checker.CheckBackwardCompatibilityUntilLevel(bcConfig, diffReport, operationsSources, level), diff --git a/internal/checks.go b/internal/checks.go index b56c27cc..9029cf5d 100644 --- a/internal/checks.go +++ b/internal/checks.go @@ -3,10 +3,12 @@ package internal import ( "fmt" "io" + "sort" "strings" "github.com/spf13/cobra" "github.com/tufin/oasdiff/checker" + "github.com/tufin/oasdiff/checker/localizations" "github.com/tufin/oasdiff/formatters" "golang.org/x/exp/slices" ) @@ -41,7 +43,7 @@ func getChecksCmd() *cobra.Command { }, } - enumWithOptions(&cmd, newEnumValue([]string{LangEn, LangRu}, LangDefault, &flags.lang), "lang", "l", "language for localized output") + enumWithOptions(&cmd, newEnumValue(localizations.GetSupportedLanguages(), localizations.LangDefault, &flags.lang), "lang", "l", "language for localized output") enumWithOptions(&cmd, newEnumValue(formatters.SupportedFormatsByContentType(formatters.OutputChecks), string(formatters.FormatText), &flags.format), "format", "f", "output format") enumWithOptions(&cmd, newEnumSliceValue([]string{"info", "warn", "error"}, nil, &flags.severity), "severity", "s", "list of severities to include (experimental)") cmd.PersistentFlags().StringSliceVarP(&flags.tags, "tags", "t", []string{}, "list of tags to include, eg. parameter, request (experimental)") @@ -51,18 +53,17 @@ func getChecksCmd() *cobra.Command { } func runChecks(stdout io.Writer, flags ChecksFlags) *ReturnError { + return outputChecks(stdout, flags, getRules(flags.required, checker.NewLocalizer(flags.lang))) +} - rules := []checker.BackwardCompatibilityRule{} - if flags.required == "all" { - rules = checker.GetAllRules() - } else if flags.required == "false" { - rules = checker.GetOptionalRules() - } else if flags.required == "true" { - rules = checker.GetRequiredRules() - } - - if err := outputChecks(stdout, flags, rules); err != nil { - return err +func getRules(required string, l checker.Localizer) []checker.BackwardCompatibilityRule { + switch required { + case "all": + return checker.GetAllRules(l) + case "false": + return checker.GetOptionalRules(l) + case "true": + return checker.GetRequiredRules(l) } return nil @@ -78,7 +79,7 @@ func outputChecks(stdout io.Writer, flags ChecksFlags, rules []checker.BackwardC } // filter rules - checks := make([]formatters.Check, 0, len(rules)) + checks := make(formatters.Checks, 0, len(rules)) for _, rule := range rules { // severity if len(flags.severity) > 0 { @@ -113,9 +114,12 @@ func outputChecks(stdout io.Writer, flags ChecksFlags, rules []checker.BackwardC Description: rule.Description, Required: rule.Required, }) + + sort.Sort(checks) } // render + sort.Sort(checks) bytes, err := formatter.RenderChecks(checks, formatters.RenderOpts{}) if err != nil { return getErrFailedPrint("checks "+flags.format, err) diff --git a/internal/lang.go b/internal/lang.go deleted file mode 100644 index bad9e936..00000000 --- a/internal/lang.go +++ /dev/null @@ -1,7 +0,0 @@ -package internal - -const ( - LangDefault = LangEn - LangEn = "en" - LangRu = "ru" -) diff --git a/internal/run_test.go b/internal/run_test.go index e4e66901..f4a1a9be 100644 --- a/internal/run_test.go +++ b/internal/run_test.go @@ -275,5 +275,5 @@ func Test_FlattenInvalid(t *testing.T) { } func Test_Checks(t *testing.T) { - require.Zero(t, internal.Run(cmdToArgs("oasdiff checks"), io.Discard, io.Discard)) + require.Zero(t, internal.Run(cmdToArgs("oasdiff checks -l ru"), io.Discard, io.Discard)) }