Separate schema validation restrictions to own files (#352)

Author: twsouthwick

DocumentFormat.OpenXml/Validation/Schema/Restrictions/AnyUriRestriction.cs

@@ -0,0 +1,55 @@
+// Copyright (c) Microsoft. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+using System;
+using System.Diagnostics;
+using System.Runtime.Serialization;
+
+namespace DocumentFormat.OpenXml.Internal.SchemaValidation
+{
+    /// <summary>
+    /// AnyURI (xsd:anyURI) based simple type constraint.
+    /// </summary>
+    /// <remarks>
+    /// anyURI represents a Uniform Resource Identifier Reference (URI).
+    /// An anyURI value can be absolute or relative, and may have an optional fragment identifier (i.e., it may be a URI Reference).
+    /// This type should be used to specify the intention that the value fulfills the role of a URI as defined by [RFC 2396], as amended by [RFC 2732].
+    /// </remarks>
+    [DataContract]
+    internal class AnyUriRestriction : StringRestriction
+    {
+        [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+        private static char[] WhitespaceChars = new char[] { ' ', '\t', '\n', '\r' };
+
+        /// <inheritdoc />
+        public override XsdType XsdType => XsdType.AnyURI;
+
+        /// <inheritdoc />
+        public override string ClrTypeName => typeof(Uri).Name;
+
+        /// <inheritdoc />
+        public override bool ValidateValueType(OpenXmlSimpleType attributeValue)
+        {
+            Uri result = null;
+            Debug.Assert(attributeValue != null);
+            string uriString = attributeValue.InnerText;
+
+            // code copied from XmlConvert.TryToUri()
+
+            if ((uriString != null) && (uriString.Length > 0))
+            {
+                uriString = uriString.Trim(WhitespaceChars);
+                if ((uriString.Length == 0) || (uriString.IndexOf("##", StringComparison.Ordinal) != -1))
+                {
+                    return false;
+                }
+            }
+            if (!Uri.TryCreate(uriString, UriHelper.RelativeOrAbsolute, out result))
+            {
+                return false;
+            }
+
+            return true;
+        }
+    }
+}

DocumentFormat.OpenXml/Validation/Schema/Restrictions/Base64BinaryRestriction.cs

@@ -0,0 +1,57 @@
+// Copyright (c) Microsoft. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+using DocumentFormat.OpenXml.Validation;
+using System;
+using System.Runtime.Serialization;
+
+namespace DocumentFormat.OpenXml.Internal.SchemaValidation
+{
+    /// <summary>
+    /// Base64 binary (xsd:base64Binary) based simple type constraint.
+    /// </summary>
+    /// <remarks>
+    /// The lexical forms of base64Binary values are limited to the 65 characters of the Base64 Alphabet defined in [RFC 2045], i.e., a-z, A-Z, 0-9, the plus sign (+), the forward slash (/) and the equal sign (=), together with the characters defined in [XML 1.0 (Second Edition)] as white space. No other characters are allowed.
+    /// </remarks>
+    [DataContract]
+    internal class Base64BinaryRestriction : StringRestriction
+    {
+        /// <inheritdoc />
+        public override XsdType XsdType => XsdType.Base64Binary;
+
+        /// <inheritdoc />
+        public override string ClrTypeName => ValidationResources.TypeName_base64Binary;
+
+        /// <inheritdoc />
+        public override bool ValidateValueType(OpenXmlSimpleType attributeValue)
+        {
+            if (attributeValue.InnerText == null)
+            {
+                return false;
+            }
+            else if (attributeValue.InnerText.Length == 0)
+            {
+                return true;
+            }
+
+            try
+            {
+                Convert.FromBase64String(attributeValue.InnerText);
+            }
+            catch (FormatException)
+            {
+                return false;
+            }
+
+            return true;
+        }
+
+        /// <inheritdoc />
+        internal override int GetValueLength(OpenXmlSimpleType attributeValue)
+        {
+            // decoded the data
+            var binaryData = Convert.FromBase64String(attributeValue.InnerText);
+            return binaryData.Length;
+        }
+    }
+}

DocumentFormat.OpenXml/Validation/Schema/Restrictions/BooleanValueRestriction.cs

@@ -0,0 +1,43 @@
+// Copyright (c) Microsoft. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+using System;
+using System.Diagnostics;
+using System.Runtime.Serialization;
+
+namespace DocumentFormat.OpenXml.Internal.SchemaValidation
+{
+    /// <summary>
+    /// Boolean (xsd:boolean) based simple type constraint.
+    /// </summary>
+    [DataContract]
+    internal class BooleanValueRestriction : SimpleTypeRestriction
+    {
+        // BooleanValueRestriction is the only SimpleTypeRestriction that can have
+        // multiple values of XsdType, so we only need to serialize this instance
+        [DataMember(Name = nameof(XsdType))]
+        private XsdType _xsdType = XsdType.Boolean;
+
+        /// <inheritdoc />
+        public override XsdType XsdType => _xsdType;
+
+        public void SetXsdType(XsdType value)
+        {
+            Debug.Assert(value == XsdType.Boolean || value == XsdType.SpecialBoolean);
+            this._xsdType = value;
+        }
+
+        /// <inheritdoc />
+        public override string ClrTypeName => typeof(Boolean).Name;
+
+#if DEBUG
+        public override void Verify()
+        {
+            Debug.Assert(this.XsdType == XsdType.Boolean || this.XsdType == XsdType.SpecialBoolean);
+            Debug.Assert(this.IsEnum == false);
+            Debug.Assert(this.IsList == false);
+            Debug.Assert(this.Pattern == null);
+        }
+#endif
+    }
+}

DocumentFormat.OpenXml/Validation/Schema/Restrictions/ByteValueRestriction.cs

@@ -0,0 +1,22 @@
+// Copyright (c) Microsoft. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+using System;
+using System.Runtime.Serialization;
+
+namespace DocumentFormat.OpenXml.Internal.SchemaValidation
+{
+    /// <summary>
+    /// Byte ( xsd:unsignedByte ) based value restriction.
+    /// </summary>
+    [DataContract]
+    internal class ByteValueRestriction : SimpleValueRestriction<Byte, ByteValue>
+    {
+        protected override Byte MinValue => Byte.MinValue;
+
+        protected override Byte MaxValue => Byte.MaxValue;
+
+        /// <inheritdoc />
+        public override XsdType XsdType => XsdType.UnsignedByte;
+    }
+}

DocumentFormat.OpenXml/Validation/Schema/Restrictions/DateTimeValueRestriction.cs

@@ -0,0 +1,22 @@
+// Copyright (c) Microsoft. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+using System;
+using System.Runtime.Serialization;
+
+namespace DocumentFormat.OpenXml.Internal.SchemaValidation
+{
+    /// <summary>
+    /// DateTime (xsd:dateTime) based value restriction.
+    /// </summary>
+    [DataContract]
+    internal class DateTimeValueRestriction : SimpleValueRestriction<DateTime, DateTimeValue>
+    {
+        protected override DateTime MinValue => DateTime.MinValue;
+
+        protected override DateTime MaxValue => DateTime.MaxValue;
+
+        /// <inheritdoc />
+        public override XsdType XsdType => XsdType.DateTime;
+    }
+}

DocumentFormat.OpenXml/Validation/Schema/Restrictions/DateValueRestriction.cs

@@ -0,0 +1,24 @@
+// Copyright (c) Microsoft. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+using System;
+using System.Runtime.Serialization;
+
+namespace DocumentFormat.OpenXml.Internal.SchemaValidation
+{
+    /// <summary>
+    /// DateTime (xsd:date) based value restriction.
+    /// </summary>
+    [DataContract]
+    internal class DateValueRestriction : SimpleValueRestriction<DateTime, DateTimeValue>
+    {
+        protected override DateTime MinValue => DateTime.MinValue;
+
+        protected override DateTime MaxValue => DateTime.MaxValue;
+
+        /// <inheritdoc />
+        public override XsdType XsdType => XsdType.Date;
+
+        // TODO: validate date.
+    }
+}

DocumentFormat.OpenXml/Validation/Schema/Restrictions/DecimalValueRestriction.cs

@@ -0,0 +1,29 @@
+// Copyright (c) Microsoft. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+using System;
+using System.Runtime.Serialization;
+
+namespace DocumentFormat.OpenXml.Internal.SchemaValidation
+{
+    /// <summary>
+    /// Decimal (xsd:decimal) based value restriction.
+    /// </summary>
+    /// <remarks>
+    /// decimal represents a subset of the real numbers, which can be represented by decimal numerals.
+    /// The ·value space· of decimal is the set of numbers that can be obtained by multiplying an integer by a non-positive power of ten,
+    /// i.e., expressible as i × 10^-n where i and n are integers and n >= 0.
+    /// Precision is not reflected in this value space; the number 2.0 is not distinct from the number 2.00.
+    /// The ·order-relation· on decimal is the order relation on real numbers, restricted to this subset.
+    /// </remarks>
+    [DataContract]
+    internal class DecimalValueRestriction : SimpleValueRestriction<Decimal, DecimalValue>
+    {
+        protected override Decimal MinValue => Decimal.MinValue;
+
+        protected override Decimal MaxValue => Decimal.MaxValue;
+
+        /// <inheritdoc />
+        public override XsdType XsdType => XsdType.Decimal;
+    }
+}

DocumentFormat.OpenXml/Validation/Schema/Restrictions/DoubleValueRestriction.cs

@@ -0,0 +1,36 @@
+// Copyright (c) Microsoft. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+using System;
+using System.Runtime.Serialization;
+
+namespace DocumentFormat.OpenXml.Internal.SchemaValidation
+{
+    /// <summary>
+    /// Double (xsd:double) based value restriction.
+    /// </summary>
+    [DataContract]
+    internal class DoubleValueRestriction : SimpleValueRestriction<Double, DoubleValue>
+    {
+        protected override Double MinValue => Double.MinValue;
+
+        protected override Double MaxValue => Double.MaxValue;
+
+        /// <inheritdoc />
+        public override XsdType XsdType => XsdType.Double;
+
+        /// <inheritdoc />
+        public override bool ValidateValueType(OpenXmlSimpleType attributeValue)
+        {
+            if (attributeValue.HasValue)
+            {
+                return true;
+
+                // TODO: is NaN valid?
+                //double value = ((DoubleValue)attributeValue).Value;
+                //return !double.IsNaN(value);
+            }
+            return false;
+        }
+    }
+}

DocumentFormat.OpenXml/Validation/Schema/Restrictions/EnumValueRestriction.cs

@@ -0,0 +1,37 @@
+// Copyright (c) Microsoft. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+using System.Runtime.Serialization;
+
+namespace DocumentFormat.OpenXml.Internal.SchemaValidation
+{
+    /// <summary>
+    /// Class for all string enum based simple types.
+    /// </summary>
+    /// <remarks>
+    /// We do not save the enums in the database. Instead we reuse the generated enum class in the generated code.
+    /// For attributes, the type of the enum is known through the code-gen'ed data.
+    /// </remarks>
+    [DataContract]
+    internal class EnumValueRestriction : SimpleTypeRestriction
+    {
+        /// <inheritdoc />
+        public override XsdType XsdType => XsdType.Enum;
+
+        /// <inheritdoc />
+        public override bool IsEnum => true;
+
+        /// <inheritdoc />
+        public override bool ValidateValueType(OpenXmlSimpleType attributeValue)
+        {
+            if (attributeValue.HasValue)
+            {
+                // Items in the enum are merged from both Office2007 and Office2010.
+                // So, we should report error when the item is not defined in the specified version.
+
+                return attributeValue.IsInVersion(this.FileFormat);
+            }
+            return false;
+        }
+    }
+}

DocumentFormat.OpenXml/Validation/Schema/Restrictions/HexBinaryRestriction.cs

@@ -0,0 +1,54 @@
+// Copyright (c) Microsoft. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+using DocumentFormat.OpenXml.Validation;
+using System.Runtime.Serialization;
+using System.Text.RegularExpressions;
+
+namespace DocumentFormat.OpenXml.Internal.SchemaValidation
+{
+    /// <summary>
+    /// Hex binary (xsd:hexBinary) based simple type constraint.
+    /// </summary>
+    /// <remarks>
+    /// hexBinary has a lexical representation where each binary octet is encoded as a character tuple,
+    /// consisting of two hexadecimal digits ([0-9a-fA-F]) representing the octet code.
+    /// For example, "0FB7" is a hex encoding for the 16-bit integer 4023 (whose binary representation is 111110110111).
+    /// </remarks>
+    [DataContract]
+    internal class HexBinaryRestriction : StringRestriction
+    {
+        /// <inheritdoc />
+        public override XsdType XsdType => XsdType.HexBinary;
+
+        /// <inheritdoc />
+        public override string ClrTypeName => ValidationResources.TypeName_hexBinary;
+
+        /// <inheritdoc />
+        public override bool ValidateValueType(OpenXmlSimpleType attributeValue)
+        {
+            if (attributeValue.InnerText == null)
+            {
+                return false;
+            }
+            else if (attributeValue.InnerText.Length == 0)
+            {
+                return true;
+            }
+
+            string pattern = @"\A([0-9a-fA-F][0-9a-fA-F])+\z";
+
+            return Regex.IsMatch(attributeValue.InnerText, pattern, RegexOptions.CultureInvariant);
+        }
+
+        /// <inheritdoc />
+        internal override int GetValueLength(OpenXmlSimpleType attributeValue)
+        {
+            // so, the data length is the number of octets
+            // then the data lenght is string lenght / 2
+            var stringLength = attributeValue.InnerText.Length;
+            //Debug.Assert(stringLength % 2 == 0);
+            return (stringLength + 1) / 2;
+        }
+    }
+}