dotnetrdf · kal · Jun 30, 2019 · Mar 11, 2019 · Mar 11, 2019 · Mar 12, 2019
diff --git a/Libraries/dotNetRDF/Core/WrapperNode.cs b/Libraries/dotNetRDF/Core/WrapperNode.cs
@@ -27,19 +27,21 @@
 namespace VDS.RDF
 {
     using System;
+    using System.Diagnostics;
     using VDS.RDF.Writing;
     using VDS.RDF.Writing.Formatting;
 
     /// <summary>
     /// Abstract decorator for Nodes to make it easier to layer functionality on top of existing implementations.
     /// </summary>
-    public abstract partial class WrapperNode : INode
+    public abstract partial class WrapperNode : INode, IBlankNode, IUriNode, ILiteralNode
     {
         /// <summary>
         /// Initializes a new instance of the <see cref="WrapperNode"/> class.
         /// </summary>
         /// <param name="node">The node this is a wrapper around.</param>
         /// <exception cref="ArgumentNullException">When <paramref name="node"/> is null.</exception>
+        [DebuggerStepThrough]
         protected WrapperNode(INode node)
         {
             Node = node ?? throw new ArgumentNullException(nameof(node));
@@ -77,6 +79,76 @@ public Uri GraphUri
             }
         }
 
+        /// <inheritdoc/>
+        string IBlankNode.InternalID
+        {
+            get
+            {
+                if (Node.NodeType != NodeType.Blank)
+                {
+                    throw new InvalidCastException();
+                }
+
+                return ((IBlankNode)Node).InternalID;
+            }
+        }
+
+        /// <inheritdoc/>
+        Uri IUriNode.Uri
+        {
+            get
+            {
+                if (Node.NodeType != NodeType.Uri)
+                {
+                    throw new InvalidCastException();
+                }
+
+                return ((IUriNode)Node).Uri;
+            }
+        }
+
+        /// <inheritdoc/>
+        string ILiteralNode.Value
+        {
+            get
+            {
+                if (Node.NodeType != NodeType.Literal)
+                {
+                    throw new InvalidCastException();
+                }
+
+                return ((ILiteralNode)Node).Value;
+            }
+        }
+
+        /// <inheritdoc/>
+        string ILiteralNode.Language
+        {
+            get
+            {
+                if (Node.NodeType != NodeType.Literal)
+                {
+                    throw new InvalidCastException();
+                }
+
+                return ((ILiteralNode)Node).Language;
+            }
+        }
+
+        /// <inheritdoc/>
+        Uri ILiteralNode.DataType
+        {
+            get
+            {
+                if (Node.NodeType != NodeType.Literal)
+                {
+                    throw new InvalidCastException();
+                }
+
+                return ((ILiteralNode)Node).DataType;
+            }
+        }
+
         /// <summary>
         /// Gets the underlying node this is a wrapper around.
         /// </summary>

diff --git a/Libraries/dotNetRDF/Shacl/Constraint.cs b/Libraries/dotNetRDF/Shacl/Constraint.cs
@@ -0,0 +1,226 @@
+/*
+// <copyright>
+// dotNetRDF is free and open source software licensed under the MIT License
+// -------------------------------------------------------------------------
+// 
+// Copyright (c) 2009-2017 dotNetRDF Project (http://dotnetrdf.org/)
+// 
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is furnished
+// to do so, subject to the following conditions:
+// 
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+// 
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+// CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+// </copyright>
+*/
+
+namespace VDS.RDF.Shacl
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Diagnostics;
+    using System.Linq;
+    using VDS.RDF.Shacl.Constraints;
+    using VDS.RDF.Shacl.Validation;
+
+    internal abstract class Constraint : WrapperNode
+    {
+        [DebuggerStepThrough]
+        protected Constraint(Shape shape, INode value)
+            : base(value)
+        {
+            this.Shape = shape;
+        }
+
+        internal abstract INode ConstraintComponent { get; }
+
+        protected Shape Shape { get; private set; }
+
+        internal static Constraint Parse(Shape shape, INode type, INode value)
+        {
+            switch (type)
+            {
+                case INode t when t.Equals(Vocabulary.Property): return new Property(shape, value);
+                case INode t when t.Equals(Vocabulary.MaxCount): return new MaxCount(shape, value);
+                case INode t when t.Equals(Vocabulary.NodeKind): return new NodeKind(shape, value);
+                case INode t when t.Equals(Vocabulary.MinCount): return new MinCount(shape, value);
+                case INode t when t.Equals(Vocabulary.Node): return new Node(shape, value);
+                case INode t when t.Equals(Vocabulary.Datatype): return new Datatype(shape, value);
+                case INode t when t.Equals(Vocabulary.Closed): return new Closed(shape, value);
+                case INode t when t.Equals(Vocabulary.HasValue): return new HasValue(shape, value);
+                case INode t when t.Equals(Vocabulary.Or): return new Or(shape, value);
+                case INode t when t.Equals(Vocabulary.Class): return new Class(shape, value);
+                case INode t when t.Equals(Vocabulary.Not): return new Not(shape, value);
+                case INode t when t.Equals(Vocabulary.Xone): return new Xone(shape, value);
+                case INode t when t.Equals(Vocabulary.In): return new In(shape, value);
+                case INode t when t.Equals(Vocabulary.Sparql): return new Select(shape, value);
+                case INode t when t.Equals(Vocabulary.Pattern): return new Pattern(shape, value);
+                case INode t when t.Equals(Vocabulary.MinInclusive): return new MinInclusive(shape, value);
+                case INode t when t.Equals(Vocabulary.MinExclusive): return new MinExclusive(shape, value);
+                case INode t when t.Equals(Vocabulary.MaxExclusive): return new MaxExclusive(shape, value);
+                case INode t when t.Equals(Vocabulary.MinLength): return new MinLength(shape, value);
+                case INode t when t.Equals(Vocabulary.MaxInclusive): return new MaxInclusive(shape, value);
+                case INode t when t.Equals(Vocabulary.And): return new And(shape, value);
+                case INode t when t.Equals(Vocabulary.QualifiedMinCount): return new QualifiedMinCount(shape, value);
+                case INode t when t.Equals(Vocabulary.QualifiedMaxCount): return new QualifiedMaxCount(shape, value);
+                case INode t when t.Equals(Vocabulary.EqualsNode): return new Equals(shape, value);
+                case INode t when t.Equals(Vocabulary.LanguageIn): return new LanguageIn(shape, value);
+                case INode t when t.Equals(Vocabulary.LessThan): return new LessThan(shape, value);
+                case INode t when t.Equals(Vocabulary.Disjoint): return new Disjoint(shape, value);
+                case INode t when t.Equals(Vocabulary.LessThanOrEquals): return new LessThanOrEquals(shape, value);
+                case INode t when t.Equals(Vocabulary.UniqueLang): return new UniqueLang(shape, value);
+                case INode t when t.Equals(Vocabulary.MaxLength): return new MaxLength(shape, value);
+
+                default: throw new Exception();
+            }
+        }
+
+        internal abstract bool Validate(INode focusNode, IEnumerable<INode> valueNodes, Report report);
+
+        protected bool ReportValueNodes(INode focusNode, IEnumerable<INode> invalidValues, Report report)
+        {
+            var allValid = !invalidValues.Any();
+
+            if (report is null)
+            {
+                return allValid;
+            }
+
+            if (allValid)
+            {
+                return true;
+            }
+
+            foreach (var invalidValue in invalidValues)
+            {
+                var result = Result.Create(report.Graph);
+                result.SourceConstraintComponent = ConstraintComponent;
+                result.Severity = Shape.Severity;
+                result.Message = Shape.Message;
+                result.SourceShape = Shape;
+                result.FocusNode = focusNode;
+
+                if (Shape is Shapes.Property propertyShape)
+                {
+                    result.ResultPath = propertyShape.Path;
+                    report.Graph.Assert(propertyShape.Path.AsTriples.Select(t => t.CopyTriple(report.Graph)));
+                }
+
+                result.ResultValue = invalidValue;
+
+                report.Results.Add(result);
+            }
+
+            return false;
+        }
+
+        protected bool ReportValueNodes(IEnumerable<Triple> invalidValues, Report report)
+        {
+            var allValid = !invalidValues.Any();
+
+            if (report is null)
+            {
+                return allValid;
+            }
+
+            if (allValid)
+            {
+                return true;
+            }
+
+            foreach (var invalidValue in invalidValues)
+            {
+                var result = Result.Create(report.Graph);
+                result.SourceConstraintComponent = ConstraintComponent;
+                result.Severity = Shape.Severity;
+                result.Message = Shape.Message;
+                result.SourceShape = Shape;
+                result.FocusNode = invalidValue.Subject;
+                result.ResultPath = Path.Parse(invalidValue.Predicate);
+                report.Graph.Assert(result.ResultPath.AsTriples.Select(t => t.CopyTriple(report.Graph)));
+                result.ResultValue = invalidValue.Object;
+
+                report.Results.Add(result);
+            }
+
+            return false;
+        }
+
+        protected bool ReportFocusNode(INode focusNode, IEnumerable<INode> invalidValues, Report report)
+        {
+            var allValid = !invalidValues.Any();
+
+            if (report is null)
+            {
+                return allValid;
+            }
+
+            if (allValid)
+            {
+                return true;
+            }
+
+            var result = Result.Create(report.Graph);
+            result.SourceConstraintComponent = ConstraintComponent;
+            result.Severity = Shape.Severity;
+            result.Message = Shape.Message;
+            result.SourceShape = Shape;
+            result.FocusNode = focusNode;
+
+            if (Shape is Shapes.Property propertyShape)
+            {
+                result.ResultPath = propertyShape.Path;
+                report.Graph.Assert(propertyShape.Path.AsTriples.Select(t => t.CopyTriple(report.Graph)));
+            }
+
+            report.Results.Add(result);
+
+            return false;
+        }
+
+        protected bool ReportFocusNodes(INode focusNode, IEnumerable<INode> invalidValues, Report report)
+        {
+            var allValid = !invalidValues.Any();
+
+            if (report is null)
+            {
+                return allValid;
+            }
+
+            if (allValid)
+            {
+                return true;
+            }
+
+            foreach (var invalidValue in invalidValues)
+            {
+                var result = Result.Create(report.Graph);
+                result.SourceConstraintComponent = ConstraintComponent;
+                result.Severity = Shape.Severity;
+                result.Message = Shape.Message;
+                result.SourceShape = Shape;
+                result.FocusNode = focusNode;
+
+                if (Shape is Shapes.Property propertyShape)
+                {
+                    result.ResultPath = propertyShape.Path;
+                    report.Graph.Assert(propertyShape.Path.AsTriples.Select(t => t.CopyTriple(report.Graph)));
+                }
+
+                report.Results.Add(result);
+            }
+
+            return false;
+        }
+    }
+}