8000 Added Addtional Validation Attributes by dchristian3188 · Pull Request #4084 · PowerShell/PowerShell · GitHub
[go: up one dir, main page]
Skip to content

Added Addtional Validation Attributes #4084

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
lzybkr merged 12 commits into from
Aug 2, 2017
Merged

Added Addtional Validation Attributes #4084

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
12 commits
Select commit Hold shift + click to select a range
e9bebef
Added Addtional Validation Attributes
dchristian3188 Jun 22, 2017
ca4125e
Updated Attributes
dchristian3188 Jun 23, 2017
5e20f99
Updated ValidateRange tests and code
dchristian3188 Jun 26, 2017
31570a0
Adding addtional element checks. Cleaned up error messages.
dchristian3188 Jun 30, 2017
1c657ce
Cleaned up methods
dchristian3188 Jun 30, 2017
f7344f3
renamed static variables
dchristian3188 Jul 1, 2017
6b39162
Removed Static and Dynamic Variables
dchristian3188 Jul 29, 2017
f64f59a
Changed to Typeof int
dchristian3188 Jul 29, 2017
a8bcc97
Removed Uneeded variable, changes to Metadata
dchristian3188 Jul 30, 2017
3eca44b
Cleaned up messages and tests
dchristian3188 Aug 2, 2017
7ff5f79
Update Metadata.resx
lzybkr Aug 2, 2017
1249e78
Update Metadata.resx
lzybkr Aug 2, 2017
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
193 changes: 165 additions & 28 deletions src/System.Management.Automation/engine/Attributes.cs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -896,6 +896,31 @@ public ValidateLengthAttribute(int minLength, int maxLength) : base()
}
}

/// <Summary>
/// Predefined range kind to use with ValidateRangeAttribute.
/// </Summary>
public enum ValidateRangeKind
{
/// <Summary>
/// Range is greater than 0.
/// </Summary>
Positive,

/// <Summary>
/// Range is greater than or equal to 0.
/// </Summary>
NonNegative,

/// <Summary>
/// Range is less than 0.
/// </Summary>
Negative,

/// <Summary>
/// Range is less than or equal to 0.
/// </Summary>
NonPositive
}
/// <summary>
/// Validates that each parameter argument falls in the range
/// specified by MinRange and MaxRange
Expand Down Expand Up @@ -923,6 +948,8 @@ public sealed class ValidateRangeAttribute : ValidateEnumeratedArgumentsAttribut
/// </summary>
private Type _promotedType;

ValidateRangeKind? _rangeKind;

/// <summary>
/// Validates that each parameter argument falls in the range
/// specified by MinRange and MaxRange
Expand All @@ -948,37 +975,14 @@ protected override void ValidateElement(object element)
{
element = o.BaseObject;
}

// minRange and maxRange have the same type, so we just need
// to compare to one of them
if (element.GetType() != _promotedType)

if (_rangeKind.HasValue)
{
object resultValue;
if (LanguagePrimitives.TryConvertTo(element, _promotedType, out resultValue))
{
element = resultValue;
}
else
{
throw new ValidationMetadataException("ValidationRangeElementType",
null, Metadata.ValidateRangeElementType,
element.GetType().Name, MinRange.GetType().Name);
}
ValidateRange(element, (ValidateRangeKind)_rangeKind);
}

// They are the same type and are all IComparable, so this should not throw
if (_minComparable.CompareTo(element) > 0)
{
throw new ValidationMetadataException("ValidateRangeTooSmall",
null, Metadata.ValidateRangeSmallerThanMinRangeFailure,
element.ToString(), MinRange.ToString());
}

if (_maxComparable.CompareTo(element) < 0)
else
{
throw new ValidationMetadataException("ValidateRangeTooBig",
null, Metadata.ValidateRangeGreaterThanMaxRangeFailure,
element.ToString(), MaxRange.ToString());
ValidateRange(element);
}
}

Expand Down Expand Up @@ -1055,6 +1059,139 @@ public ValidateRangeAttribute(object minRange, object maxRange) : base()
MaxRange = maxRange;
}

/// <summary>
/// Initializes a new instance of the ValidateRangeAttribute class
/// this constructor uses a predefined ranged
/// </summary>
public ValidateRangeAttribute(ValidateRangeKind kind) : base()
{
_rangeKind = kind;
}

private void ValidateRange(object element, ValidateRangeKind rangeKind)
{
Type commonType = GetCommonType(typeof(int),element.GetType());
if (commonType == null)
{
throw new ValidationMetadataException(
"ValidationRangeElementType",
null,
Metadata.ValidateRangeElementType,
element.GetType().Name,
typeof(int).Name);
}

object resultValue;
IComparable dynamicZero = 0;

if (LanguagePrimitives.TryConvertTo(element, commonType, out resultValue))
{
element = resultValue;

if (LanguagePrimitives.TryConvertTo(0, commonType, out resultValue))
{
dynamicZero = (IComparable)resultValue;
}
}
else
{
throw new ValidationMetadataException(
"ValidationRangeElementType",
null,
Metadata.ValidateRangeElementType,
element.GetType().Name,
commonType.Name);
}

switch (rangeKind)
{
case ValidateRangeKind.Positive:
if (dynamicZero.CompareTo(element) >= 0)
{
throw new ValidationMetadataException(
"ValidateRangePositiveFailure",
null,
Metadata.ValidateRangePositiveFailure,
element.ToString());
}
break;
case ValidateRangeKind.NonNegative:
if (dynamicZero.CompareTo(element) > 0)
{
throw new ValidationMetadataException(
"ValidateRangeNonNegativeFailure",
null,
Metadata.ValidateRangeNonNegativeFailure,
element.ToString());
}
break;
case ValidateRangeKind.Negative:
if (dynamicZero.CompareTo(element) <= 0)
{
throw new ValidationMetadataException(
"ValidateRangeNegativeFailure",
null,
Metadata.ValidateRangeNegativeFailure,
element.ToString());
}
break;
case ValidateRangeKind.NonPositive:
if (dynamicZero.CompareTo(element) < 0)
{
throw new ValidationMetadataException(
"ValidateRangeNonPositiveFailure",
null,
Metadata.ValidateRangeNonPositiveFailure,
element.ToString());
}
break;
}
}

private void ValidateRange(object element)
{
// MinRange and maxRange have the same type, so we just need
// to compare to one of them.
if (element.GetType() != _promotedType)
{
object resultValue;
if (LanguagePrimitives.TryConvertTo(element, _promotedType, out resultValue))
{
element = resultValue;
}
else
{
throw new ValidationMetadataException(
"ValidationRangeElementType",
null,
Metadata.ValidateRangeElementType,
element.GetType().Name,
MinRange.GetType().Name);
}
}

// They are the same type and are all IComparable, so this should not throw
if (_minComparable.CompareTo(element) > 0)
{
throw new ValidationMetadataException(
"ValidateRangeTooSmall",
null,
Metadata.ValidateRangeSmallerThanMinRangeFailure,
element.ToString(),
MinRange.ToString());
}

if (_maxComparable.CompareTo(element) < 0)
{
throw new ValidationMetadataException(
"ValidateRangeTooBig",
null,
Metadata.ValidateRangeGreaterThanMaxRangeFailure,
element.ToString(),
MaxRange.ToString());
}
}

private static Type GetCommonType(Type minType, Type maxType)
{
Type resultType = null;
Expand Down
12 changes: 12 additions & 0 deletions src/System.Management.Automation/resources/Metadata.resx
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -123,6 +123,18 @@
<data name="ValidateRangeElementType" xml:space="preserve">
<value>The argument cannot be validated because its type "{0}" is not the same type ({1}) as the maximum and minimum limits of the parameter. Make sure the argument is of type {1} and then try the command again.</value>
</data>
<data name="ValidateRangePositiveFailure" xml:space="preserve">
<value>The argument "{0}" cannot be validated because its value is not greater than zero.</value>
Copy link
Collaborator
@iSazonov iSazonov Jul 30, 2017

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

We can "validate" but cannot "accept". Maybe better change this. Below too.

Copy link
Contributor Author
@dchristian3188 dchristian3188 Jul 30, 2017

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

You're right, this does make more sense. It also follows the same verbiage as existing Validate Range

</data>
<data name="ValidateRangeNonNegativeFailure" xml:space="preserve">
<value>The argument "{0}" cannot be validated because its value is not greater than or equal to zero.</value>
</data>
<data name="ValidateRangeNegativeFailure" xml:space="preserve">
<value>The argument "{0}" cannot be validated because its value is not less than zero.</value>
</data>
<data name="ValidateRangeNonPositiveFailure" xml:space="preserve">
<value>The argument "{0}" cannot be validated because its value is not less than or equal to zero.</value>
</data>
<data name="ValidateRangeMinRangeMaxRangeType" xml:space="preserve">
<value>The specified minimum range ({0}) cannot be accepted because it is not the same type as the specified maximum range ({1}). Update the ValidateRange attribute for the parameter.</value>
</data>
Expand Down
4 changes: 4 additions & 0 deletions src/System.Management.Automation/utils/MetadataExceptions.cs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -72,6 +72,10 @@ internal MetadataException(string errorId, Exception innerException, string reso
public class ValidationMetadataException : MetadataException
{
internal const string ValidateRangeElementType = "ValidateRangeElementType";
internal const string ValidateRangePositiveFailure = "ValidateRangePositiveFailure";
internal const string ValidateRangeNonNegativeFailure = "ValidateRangeNonNegativeFailure";
internal const string ValidateRangeNegativeFailure = "ValidateRangeNegativeFailure";
internal const string ValidateRangeNonPositiveFailure = "ValidateRangeNonPositiveFailure";
internal const string ValidateRangeMinRangeMaxRangeType = "ValidateRangeMinRangeMaxRangeType";
internal const string ValidateRangeNotIComparable = "ValidateRangeNotIComparable";
internal const string ValidateRangeMaxRangeSmallerThanMinRange = "ValidateRangeMaxRangeSmallerThanMinRange";
Expand Down
Loading
0