Add basic PlantUML support for feature request #78 (2nd attempt)

.gitignore

@@ -57,6 +57,8 @@ fabric.properties
 list_license.ps1
 **/LicenseSources/
 
+.vs/
+
 *.user
 
 # Visual Studio cache/options directory

ArchUnitNET/Domain/PlantUml/Alias.cs

@@ -0,0 +1,35 @@
+using System;
+using System.Collections.Generic;
+
+namespace ArchUnitNET.Domain.PlantUml
+{
+    internal class Alias
+    {
+        private string _value;
+
+        public Alias(string value)
+        {
+            if (value.Contains("[") || value.Contains("]") || value.Contains(@""""))
+            {
+                throw new IllegalDiagramException(string.Format(@"Alias '{0}' should not contain character(s): '[' or ']' or '""'", value));
+            }
+            _value = value ?? throw new ArgumentNullException(nameof(value));
+        }
+
+        public override bool Equals(object obj)
+        {
+            return obj is Alias alias &&
+                   _value == alias._value;
+        }
+
+        public override int GetHashCode()
+        {
+            return -1939223833 + EqualityComparer<string>.Default.GetHashCode(_value);
+        }
+
+        internal string asString()
+        {
+            return _value;
+        }
+    }
+}

ArchUnitNET/Domain/PlantUml/ClassDiagramAssociation.cs

@@ -0,0 +1,146 @@
+using ArchUnitNET.Domain;
+using ArchUnitNET.Domain.Extensions;
+using ArchUnitNET.Fluent.Conditions;
+using System;
+using System.Collections.Generic;
+using System.Collections.Immutable;
+using System.Linq;
+
+namespace ArchUnitNET.Domain.PlantUml
+{
+    internal class ClassDiagramAssociation
+    {
+        private readonly ImmutableHashSet<AssociatedComponent> _components;
+
+        public ClassDiagramAssociation(PlantUmlDiagram diagram)
+        {
+            var components = ImmutableHashSet.CreateBuilder<AssociatedComponent>();
+            ValidateStereotypes(diagram);
+            foreach (var component in diagram.AllComponents)
+            {
+                components.Add(new AssociatedComponent(component));
+            }
+            _components = components.ToImmutable();
+        }
+
+        private void ValidateStereotypes(PlantUmlDiagram plantUmlDiagram)
+        {
+            ISet<Stereotype> visited = new HashSet<Stereotype>();
+            foreach (PlantUmlComponent component in plantUmlDiagram.AllComponents)
+            {
+                foreach (Stereotype stereotype in component.Stereotypes)
+                {
+                    if (visited.Contains(stereotype))
+                    {
+                        throw new IllegalDiagramException(string.Format("Stereotype '{0}' should be unique", stereotype.AsString()));
+                    }
+                    visited.Add(stereotype);
+                }
+            }
+        }
+
+        public ISet<string> GetTargetNamespaceIdentifiers(IType clazz)
+        {
+            var result = ImmutableHashSet.CreateBuilder<string>();
+            foreach (PlantUmlComponent target in GetComponentOf(clazz).Dependencies)
+            {
+                foreach (string identifier in GetNamespaceIdentifiersFromComponentOf(target))
+                {
+                    result.Add(identifier);
+                }
+            }
+            return result.ToImmutable();
+        }
+
+        public bool Contains(IType clazz)
+        {
+            return GetAssociatedComponents(clazz).Count > 0;
+        }
+
+        public ISet<string> GetNamespaceIdentifiersFromComponentOf(IType javaIType)
+        {
+            return GetNamespaceIdentifiersFromComponentOf(GetComponentOf(javaIType));
+        }
+
+        private ISet<string> GetNamespaceIdentifiersFromComponentOf(PlantUmlComponent component)
+        {
+            var result = ImmutableHashSet.CreateBuilder<string>();
+            foreach (Stereotype stereotype in component.Stereotypes)
+            {
+                result.Add(stereotype.AsString());
+            }
+            return result.ToImmutable();
+        }
+
+        private PlantUmlComponent GetComponentOf(IType clazz)
+        {
+            ISet<PlantUmlComponent> associatedComponents = GetAssociatedComponents(clazz);
+
+            if (associatedComponents.Count > 1)
+            {
+                throw new ComponentIntersectionException(
+                        string.Format("Class {0} may not be contained in more than one component, but is contained in [{1}]",
+                                clazz.Name,
+                                string.Join(", ", GetComponentNames(associatedComponents))));
+            }
+            else if (associatedComponents.Count == 0)
+            {
+                throw new InvalidOperationException(string.Format("Class {0} is not contained in any component", clazz.Name));
+            }
+
+            return associatedComponents.Single();
+        }
+
+        private ISet<string> GetComponentNames(ISet<PlantUmlComponent> associatedComponents)
+        {
+            ISet<string> associatedComponentNames = new HashSet<string>();
+            foreach (PlantUmlComponent associatedComponent in associatedComponents)
+            {
+                associatedComponentNames.Add(associatedComponent.ComponentName.AsString());
+            }
+            return associatedComponentNames;
+        }
+
+        private ISet<PlantUmlComponent> GetAssociatedComponents(IType clazz)
+        {
+            var result = ImmutableHashSet.CreateBuilder<PlantUmlComponent>();
+            foreach (AssociatedComponent component in _components)
+            {
+                if (component.Contains(clazz))
+                {
+                    result.Add(component.AsPlantUmlComponent);
+                }
+            }
+            return result.ToImmutable();
+        }
+
+        private class AssociatedComponent
+        {
+            private readonly PlantUmlComponent _component;
+
+            public AssociatedComponent(PlantUmlComponent component)
+            {
+                _component = component;
+            }
+
+            public PlantUmlComponent AsPlantUmlComponent
+            {
+                get { return _component; }
+            }
+
+            public bool Contains(IType clazz)
+            {
+                foreach (Stereotype stereotype in _component.Stereotypes)
+                {
+                    if (clazz.ResidesInNamespace(stereotype.AsString(), true))
+                    {
+                        return true;
+                    }
+                }
+                return false;
+            }
+
+
+        }
+    }
+}

ArchUnitNET/Domain/PlantUml/ComponentIdentifier.cs

@@ -0,0 +1,38 @@
+using System.Collections.Generic;
+
+namespace ArchUnitNET.Domain.PlantUml
+{
+    internal class ComponentIdentifier
+    {
+        public ComponentIdentifier(ComponentName componentName) : this(componentName, null)
+        { }
+
+        public ComponentIdentifier(ComponentName componentName, Alias alias)
+        {
+            ComponentName = componentName;
+            Alias = alias;
+        }
+
+        public ComponentName ComponentName { get; private set; }
+
+        public Alias Alias { get; private set; }
+
+        public override bool Equals(object obj)
+        {
+            return obj is ComponentIdentifier identifier &&
+                   EqualityComparer<ComponentName>.Default.Equals(ComponentName, identifier.ComponentName) &&
+                   EqualityComparer<Alias>.Default.Equals(Alias, identifier.Alias);
+        }
+
+        public override int GetHashCode()
+        {
+            int hashCode = -1327966062;
+            hashCode = hashCode * -1521134295 + EqualityComparer<ComponentName>.Default.GetHashCode(ComponentName);
+            if (Alias != null)
+            {
+                hashCode = hashCode * -1521134295 + EqualityComparer<Alias>.Default.GetHashCode(Alias);
+            }
+            return hashCode;
+        }
+    }
+}

ArchUnitNET/Domain/PlantUml/ComponentIntersectionException.cs

@@ -0,0 +1,25 @@
+using System;
+using System.Runtime.Serialization;
+
+namespace ArchUnitNET.Domain.PlantUml
+{
+    [Serializable]
+    internal class ComponentIntersectionException : Exception
+    {
+        public ComponentIntersectionException()
+        {
+        }
+
+        public ComponentIntersectionException(string message) : base(message)
+        {
+        }
+
+        public ComponentIntersectionException(string message, Exception innerException) : base(message, innerException)
+        {
+        }
+
+        protected ComponentIntersectionException(SerializationInfo info, StreamingContext context) : base(info, context)
+        {
+        }
+    }
+}

ArchUnitNET/Domain/PlantUml/ComponentName.cs

@@ -0,0 +1,31 @@
+using System;
+using System.Collections.Generic;
+
+namespace ArchUnitNET.Domain.PlantUml
+{
+    internal class ComponentName
+    {
+        private readonly string _value;
+
+        public ComponentName(string value)
+        {
+            _value = value ?? throw new ArgumentNullException(nameof(value));
+        }
+
+        public string AsString()
+        {
+            return _value;
+        }
+
+        public override bool Equals(object obj)
+        {
+            return obj is ComponentName name &&
+                   _value == name._value;
+        }
+
+        public override int GetHashCode()
+        {
+            return -1939223833 + EqualityComparer<string>.Default.GetHashCode(_value);
+        }
+    }
+}

ArchUnitNET/Domain/PlantUml/IllegalDiagramException.cs

@@ -0,0 +1,32 @@
+using System;
+using System.Runtime.Serialization;
+
+namespace ArchUnitNET.Domain.PlantUml
+{
+    [Serializable]
+    internal class IllegalDiagramException : Exception
+    {
+        private object p;
+
+        public IllegalDiagramException()
+        {
+        }
+
+        public IllegalDiagramException(object p)
+        {
+            this.p = p;
+        }
+
+        public IllegalDiagramException(string message) : base(message)
+        {
+        }
+
+        public IllegalDiagramException(string message, Exception innerException) : base(message, innerException)
+        {
+        }
+
+        protected IllegalDiagramException(SerializationInfo info, StreamingContext context) : base(info, context)
+        {
+        }
+    }
+}

ArchUnitNET/Domain/PlantUml/ParsedDependency.cs

@@ -0,0 +1,37 @@
+using System.Collections.Generic;
+
+namespace ArchUnitNET.Domain.PlantUml
+{
+    internal class ParsedDependency
+    {
+        public ParsedDependency(ComponentIdentifier origin, ComponentIdentifier target)
+        {
+            Origin = origin;
+            Target = target;
+        }
+
+        public ComponentIdentifier Origin { get; }
+        public ComponentIdentifier Target { get; }
+
+        public override bool Equals(object obj)
+        {
+            return obj is ParsedDependency dependency &&
+                   EqualityComparer<ComponentIdentifier>.Default.Equals(Origin, dependency.Origin) &&
+                   EqualityComparer<ComponentIdentifier>.Default.Equals(Target, dependency.Target);
+        }
+
+        public override int GetHashCode()
+        {
+            int hashCode = -1013312977;
+            if (Origin != null)
+            {
+                hashCode = hashCode * -1521134295 + EqualityComparer<ComponentIdentifier>.Default.GetHashCode(Origin);
+            }
+            if (Target != null)
+            {
+                hashCode = hashCode * -1521134295 + EqualityComparer<ComponentIdentifier>.Default.GetHashCode(Target);
+            }
+            return hashCode;
+        }
+    }
+}