コード例 #1
0
        public void MultiLine03()
        {
            Reader      reader = Reader.CreateStringReader(ExampleStrings.EnumValue.MultiLine05);
            IDataParser parser = CreateDataParser(reader, EnumValueParser.HierarchyParser(3));

            AssertParsedUsingXml(parser, EnumValueModel.Factory("EnumValue", "TARGT-NO-AUTOGEN VALUE 'N'", "No Autogenerate Interdistrict Account\nEntries"));
        }
コード例 #2
0
        public void MultiLine13()
        {
            Reader      reader = Reader.CreateStringReader(ExampleStrings.EnumValue.SingleLine15);
            IDataParser parser = CreateDataParser(reader, EnumValueParser.HierarchyParser(8));

            AssertParsedUsingXml(parser, EnumValueModel.Factory("EnumValue", "MSF062-ETP-TRAIN-PROG VALUE 'P'", "Employee Training Plan Program"));
        }
コード例 #3
0
        public void SingleLine09()
        {
            Reader      reader = Reader.CreateStringReader(ExampleStrings.EnumValue.SingleLine11);
            IDataParser parser = CreateDataParser(reader, EnumValueParser.HierarchyParser(6));

            AssertParsedUsingXml(parser, EnumValueModel.Factory("EnumValue", "EGI-TYPE VALUE 'G'", "EGI type record"));
        }
コード例 #4
0
        public void SingleLine11()
        {
            Reader      reader = Reader.CreateStringReader(ExampleStrings.EnumValue.SingleLine13);
            IDataParser parser = CreateDataParser(reader, EnumValueParser.HierarchyParser(7));

            AssertParsedUsingXml(parser, EnumValueModel.Factory("EnumValue", "RES-TY VALUE 'R'", "Resource Type"));
        }
コード例 #5
0
        public void SingleLine03()
        {
            Reader      reader = Reader.CreateStringReader(ExampleStrings.EnumValue.SingleLine05);
            IDataParser parser = CreateDataParser(reader, EnumValueParser.HierarchyParser(3));

            AssertParsedUsingXml(parser, EnumValueModel.Factory("EnumValue", "PO-NO-ITEM VALUE 'PO'", "Purchase Order Number Item"));
        }
コード例 #6
0
        public void SingleLine07()
        {
            Reader      reader = Reader.CreateStringReader(ExampleStrings.EnumValue.SingleLine09);
            IDataParser parser = CreateDataParser(reader, EnumValueParser.HierarchyParser(5));

            AssertParsedUsingXml(parser, EnumValueModel.Factory("EnumValue", "MIMS-CONTROL VALUE 'M'", "Indicates MIMS System Control Account"));
        }
コード例 #7
0
        public void MultiLine07()
        {
            Reader      reader = Reader.CreateStringReader(ExampleStrings.EnumValue.MultiLine07);
            IDataParser parser = CreateDataParser(reader);

            AssertParsedUsingXml(parser, EnumValueModel.Factory("EnumValue", "ERROR VALUE '0001' THRU '9999' 'A000' THRU 'Z999'", "Error"));
        }
コード例 #8
0
        private static string GenerateEnumValue(EnumValueModel value)
        {
            var obsoleteAttribute = value.IsDeprecated
                    ? $@"        {AttributeGenerator.GenerateObsoleteAttribute(value.DeprecationReason)}{Environment.NewLine}"
                    : string.Empty;

            return($@"{obsoleteAttribute}        [EnumMember(Value = ""{value.Name}"")]
        {value.Name.SnakeCaseToPascalCase()},");
        }
コード例 #9
0
 private static string GenerateDocComments(EnumValueModel value)
 {
     if (!string.IsNullOrWhiteSpace(value.Description))
     {
         var builder = new StringBuilder();
         DocCommentGenerator.GenerateSummary(value.Description, 8, builder);
         return(builder.ToString());
     }
     else
     {
         return(null);
     }
 }
コード例 #10
0
        private static string GenerateDocComments(EnumValueModel value)
        {
            if (!string.IsNullOrWhiteSpace(value.Description))
            {
                return($@"        /// <summary>
        /// {value.Description}
        /// </summary>
");
            }
            else
            {
                return(null);
            }
        }
コード例 #11
0
        private TypeModel CreateTypeModel(XmlSchemaSimpleType simpleType, NamespaceModel namespaceModel, XmlQualifiedName qualifiedName, List <DocumentationModel> docs)
        {
            var restrictions = new List <RestrictionModel>();

            if (simpleType.Content is XmlSchemaSimpleTypeRestriction typeRestriction)
            {
                var enumFacets = typeRestriction.Facets.OfType <XmlSchemaEnumerationFacet>().ToList();
                // If there's a pattern restriction mixed into the enumeration values, we'll generate a string to play it safe.
                var isEnum = enumFacets.Count > 0 && !typeRestriction.Facets.OfType <XmlSchemaPatternFacet>().Any();
                if (isEnum)
                {
                    // we got an enum
                    var name = _configuration.NamingProvider.EnumTypeNameFromQualifiedName(qualifiedName);
                    if (namespaceModel != null)
                    {
                        name = namespaceModel.GetUniqueTypeName(name);
                    }

                    var enumModel = new EnumModel(_configuration)
                    {
                        Name          = name,
                        Namespace     = namespaceModel,
                        XmlSchemaName = qualifiedName,
                        XmlSchemaType = simpleType,
                        IsAnonymous   = string.IsNullOrEmpty(simpleType.QualifiedName.Name),
                    };

                    enumModel.Documentation.AddRange(docs);

                    foreach (var facet in enumFacets.DistinctBy(f => f.Value))
                    {
                        var value = new EnumValueModel
                        {
                            Name  = _configuration.NamingProvider.EnumMemberNameFromValue(enumModel.Name, facet.Value),
                            Value = facet.Value
                        };

                        var valueDocs = GetDocumentation(facet);
                        value.Documentation.AddRange(valueDocs);

                        var deprecated = facet.Annotation != null && facet.Annotation.Items.OfType <XmlSchemaAppInfo>()
                                         .Any(a => a.Markup.Any(m => m.Name == "annox:annotate" && m.HasChildNodes && m.FirstChild.Name == "jl:Deprecated"));
                        value.IsDeprecated = deprecated;

                        enumModel.Values.Add(value);
                    }

                    enumModel.Values = EnsureEnumValuesUnique(enumModel.Values);
                    if (namespaceModel != null)
                    {
                        namespaceModel.Types[enumModel.Name] = enumModel;
                    }

                    if (!qualifiedName.IsEmpty)
                    {
                        var key = BuildKey(simpleType, qualifiedName);
                        Types[key] = enumModel;
                    }

                    return(enumModel);
                }

                restrictions = GetRestrictions(typeRestriction.Facets.Cast <XmlSchemaFacet>(), simpleType).Where(r => r != null).Sanitize().ToList();
            }

            var simpleModelName = _configuration.NamingProvider.SimpleTypeNameFromQualifiedName(qualifiedName);

            if (namespaceModel != null)
            {
                simpleModelName = namespaceModel.GetUniqueTypeName(simpleModelName);
            }

            var simpleModel = new SimpleModel(_configuration)
            {
                Name          = simpleModelName,
                Namespace     = namespaceModel,
                XmlSchemaName = qualifiedName,
                XmlSchemaType = simpleType,
                ValueType     = simpleType.Datatype.GetEffectiveType(_configuration, restrictions),
            };

            simpleModel.Documentation.AddRange(docs);
            simpleModel.Restrictions.AddRange(restrictions);

            if (namespaceModel != null)
            {
                namespaceModel.Types[simpleModel.Name] = simpleModel;
            }

            if (!qualifiedName.IsEmpty)
            {
                var key = BuildKey(simpleType, qualifiedName);
                Types[key] = simpleModel;
            }

            return(simpleModel);
        }
コード例 #12
0
        private TypeModel CreateTypeModel(Uri source, XmlSchemaSimpleType simpleType, NamespaceModel namespaceModel, XmlQualifiedName qualifiedName, List <DocumentationModel> docs)
        {
            var restrictions = new List <RestrictionModel>();

            if (simpleType.Content is XmlSchemaSimpleTypeRestriction typeRestriction)
            {
                var enumFacets = typeRestriction.Facets.OfType <XmlSchemaEnumerationFacet>().ToList();
                var isEnum     = (enumFacets.Count == typeRestriction.Facets.Count && enumFacets.Count != 0) ||
                                 (EnumTypes.Contains(typeRestriction.BaseTypeName.Name) && enumFacets.Any());
                if (isEnum)
                {
                    // we got an enum
                    var name = ToTitleCase(qualifiedName.Name);
                    if (namespaceModel != null)
                    {
                        name = namespaceModel.GetUniqueTypeName(name);
                    }

                    var enumModel = new EnumModel(_configuration)
                    {
                        Name          = name,
                        Namespace     = namespaceModel,
                        XmlSchemaName = qualifiedName,
                        XmlSchemaType = simpleType,
                    };

                    enumModel.Documentation.AddRange(docs);

                    foreach (var facet in enumFacets.DistinctBy(f => f.Value))
                    {
                        var value = new EnumValueModel
                        {
                            Name  = _configuration.NamingProvider.EnumMemberNameFromValue(enumModel.Name, facet.Value),
                            Value = facet.Value
                        };

                        var valueDocs = GetDocumentation(facet);
                        value.Documentation.AddRange(valueDocs);

                        var deprecated = facet.Annotation != null && facet.Annotation.Items.OfType <XmlSchemaAppInfo>()
                                         .Any(a => a.Markup.Any(m => m.Name == "annox:annotate" && m.HasChildNodes && m.FirstChild.Name == "jl:Deprecated"));
                        value.IsDeprecated = deprecated;

                        enumModel.Values.Add(value);
                    }

                    if (namespaceModel != null)
                    {
                        namespaceModel.Types[enumModel.Name] = enumModel;
                    }

                    if (!qualifiedName.IsEmpty)
                    {
                        Types[qualifiedName] = enumModel;
                    }

                    return(enumModel);
                }

                restrictions = GetRestrictions(typeRestriction.Facets.Cast <XmlSchemaFacet>(), simpleType).Where(r => r != null).Sanitize().ToList();
            }

            var simpleModelName = ToTitleCase(qualifiedName.Name);

            if (namespaceModel != null)
            {
                simpleModelName = namespaceModel.GetUniqueTypeName(simpleModelName);
            }

            var simpleModel = new SimpleModel(_configuration)
            {
                Name          = simpleModelName,
                Namespace     = namespaceModel,
                XmlSchemaName = qualifiedName,
                XmlSchemaType = simpleType,
                ValueType     = simpleType.Datatype.GetEffectiveType(_configuration),
            };

            simpleModel.Documentation.AddRange(docs);
            simpleModel.Restrictions.AddRange(restrictions);

            if (namespaceModel != null)
            {
                namespaceModel.Types[simpleModel.Name] = simpleModel;
            }

            if (!qualifiedName.IsEmpty)
            {
                Types[qualifiedName] = simpleModel;
            }

            return(simpleModel);
        }
コード例 #13
0
        // ReSharper disable once FunctionComplexityOverflow
        private TypeModel CreateTypeModel(Uri source, XmlSchemaAnnotated type, XmlQualifiedName qualifiedName)
        {
            TypeModel typeModel;

            if (!qualifiedName.IsEmpty && Types.TryGetValue(qualifiedName, out typeModel))
            {
                return(typeModel);
            }

            if (source == null)
            {
                throw new ArgumentNullException("source");
            }
            var namespaceModel = CreateNamespaceModel(source, qualifiedName);

            var docs = GetDocumentation(type);

            var group = type as XmlSchemaGroup;

            if (group != null)
            {
                var name = "I" + ToTitleCase(qualifiedName.Name);
                if (namespaceModel != null)
                {
                    name = namespaceModel.GetUniqueTypeName(name);
                }

                var interfaceModel = new InterfaceModel(_configuration)
                {
                    Name          = name,
                    Namespace     = namespaceModel,
                    XmlSchemaName = qualifiedName
                };

                interfaceModel.Documentation.AddRange(docs);

                if (namespaceModel != null)
                {
                    namespaceModel.Types[name] = interfaceModel;
                }
                if (!qualifiedName.IsEmpty)
                {
                    Types[qualifiedName] = interfaceModel;
                }

                var particle   = group.Particle;
                var items      = GetElements(particle);
                var properties = CreatePropertiesForElements(source, interfaceModel, particle, items.Where(i => !(i.XmlParticle is XmlSchemaGroupRef)));
                interfaceModel.Properties.AddRange(properties);
                var interfaces = items.Select(i => i.XmlParticle).OfType <XmlSchemaGroupRef>()
                                 .Select(i => (InterfaceModel)CreateTypeModel(new Uri(i.SourceUri), Groups[i.RefName], i.RefName));
                interfaceModel.Interfaces.AddRange(interfaces);

                return(interfaceModel);
            }

            var attributeGroup = type as XmlSchemaAttributeGroup;

            if (attributeGroup != null)
            {
                var name = "I" + ToTitleCase(qualifiedName.Name);
                if (namespaceModel != null)
                {
                    name = namespaceModel.GetUniqueTypeName(name);
                }

                var interfaceModel = new InterfaceModel(_configuration)
                {
                    Name          = name,
                    Namespace     = namespaceModel,
                    XmlSchemaName = qualifiedName
                };

                interfaceModel.Documentation.AddRange(docs);

                if (namespaceModel != null)
                {
                    namespaceModel.Types[name] = interfaceModel;
                }
                if (!qualifiedName.IsEmpty)
                {
                    Types[qualifiedName] = interfaceModel;
                }

                var items      = attributeGroup.Attributes;
                var properties = CreatePropertiesForAttributes(source, interfaceModel, items.OfType <XmlSchemaAttribute>());
                interfaceModel.Properties.AddRange(properties);
                var interfaces = items.OfType <XmlSchemaAttributeGroupRef>()
                                 .Select(a => (InterfaceModel)CreateTypeModel(new Uri(a.SourceUri), AttributeGroups[a.RefName], a.RefName));
                interfaceModel.Interfaces.AddRange(interfaces);

                return(interfaceModel);
            }

            var complexType = type as XmlSchemaComplexType;

            if (complexType != null)
            {
                var name = ToTitleCase(qualifiedName.Name);
                if (namespaceModel != null)
                {
                    name = namespaceModel.GetUniqueTypeName(name);
                }

                var classModel = new ClassModel(_configuration)
                {
                    Name              = name,
                    Namespace         = namespaceModel,
                    XmlSchemaName     = qualifiedName,
                    XmlSchemaType     = complexType,
                    IsAbstract        = complexType.IsAbstract,
                    IsAnonymous       = complexType.QualifiedName.Name == "",
                    IsMixed           = complexType.IsMixed,
                    IsSubstitution    = complexType.Parent is XmlSchemaElement && !((XmlSchemaElement)complexType.Parent).SubstitutionGroup.IsEmpty,
                    EnableDataBinding = EnableDataBinding,
                };

                classModel.Documentation.AddRange(docs);

                if (namespaceModel != null)
                {
                    namespaceModel.Types[classModel.Name] = classModel;
                }

                if (!qualifiedName.IsEmpty)
                {
                    Types[qualifiedName] = classModel;
                }

                if (complexType.BaseXmlSchemaType != null && complexType.BaseXmlSchemaType.QualifiedName != AnyType)
                {
                    var baseModel = CreateTypeModel(source, complexType.BaseXmlSchemaType, complexType.BaseXmlSchemaType.QualifiedName);
                    classModel.BaseClass = baseModel;
                    if (baseModel is ClassModel)
                    {
                        ((ClassModel)classModel.BaseClass).DerivedTypes.Add(classModel);
                    }
                }

                XmlSchemaParticle particle = null;
                if (classModel.BaseClass != null)
                {
                    if (complexType.ContentModel.Content is XmlSchemaComplexContentExtension)
                    {
                        particle = ((XmlSchemaComplexContentExtension)complexType.ContentModel.Content).Particle;
                    }

                    // If it's a restriction, do not duplicate elements on the derived class, they're already in the base class.
                    // See https://msdn.microsoft.com/en-us/library/f3z3wh0y.aspx
                    //else if (complexType.ContentModel.Content is XmlSchemaComplexContentRestriction)
                    //    particle = ((XmlSchemaComplexContentRestriction)complexType.ContentModel.Content).Particle;
                }
                else
                {
                    particle = complexType.ContentTypeParticle;
                }

                var items      = GetElements(particle);
                var properties = CreatePropertiesForElements(source, classModel, particle, items);
                classModel.Properties.AddRange(properties);

                if (GenerateInterfaces)
                {
                    var interfaces = items.Select(i => i.XmlParticle).OfType <XmlSchemaGroupRef>()
                                     .Select(i => (InterfaceModel)CreateTypeModel(new Uri(i.SourceUri), Groups[i.RefName], i.RefName));
                    classModel.Interfaces.AddRange(interfaces);
                }

                XmlSchemaObjectCollection attributes = null;
                if (classModel.BaseClass != null)
                {
                    if (complexType.ContentModel.Content is XmlSchemaComplexContentExtension)
                    {
                        attributes = ((XmlSchemaComplexContentExtension)complexType.ContentModel.Content).Attributes;
                    }
                    else if (complexType.ContentModel.Content is XmlSchemaSimpleContentExtension)
                    {
                        attributes = ((XmlSchemaSimpleContentExtension)complexType.ContentModel.Content).Attributes;
                    }

                    // If it's a restriction, do not duplicate attributes on the derived class, they're already in the base class.
                    // See https://msdn.microsoft.com/en-us/library/f3z3wh0y.aspx
                    //else if (complexType.ContentModel.Content is XmlSchemaComplexContentRestriction)
                    //    attributes = ((XmlSchemaComplexContentRestriction)complexType.ContentModel.Content).Attributes;
                    //else if (complexType.ContentModel.Content is XmlSchemaSimpleContentRestriction)
                    //    attributes = ((XmlSchemaSimpleContentRestriction)complexType.ContentModel.Content).Attributes;
                }
                else
                {
                    attributes = complexType.Attributes;
                }

                if (attributes != null)
                {
                    var attributeProperties = CreatePropertiesForAttributes(source, classModel, attributes.Cast <XmlSchemaObject>());
                    classModel.Properties.AddRange(attributeProperties);

                    if (GenerateInterfaces)
                    {
                        var attributeInterfaces = attributes.OfType <XmlSchemaAttributeGroupRef>()
                                                  .Select(i => (InterfaceModel)CreateTypeModel(new Uri(i.SourceUri), AttributeGroups[i.RefName], i.RefName));
                        classModel.Interfaces.AddRange(attributeInterfaces);
                    }
                }

                if (complexType.AnyAttribute != null)
                {
                    var property = new PropertyModel(_configuration)
                    {
                        OwningType = classModel,
                        Name       = "AnyAttribute",
                        Type       = new SimpleModel(_configuration)
                        {
                            ValueType = typeof(XmlAttribute), UseDataTypeAttribute = false
                        },
                        IsAttribute  = true,
                        IsCollection = true,
                        IsAny        = true
                    };

                    var attributeDocs = GetDocumentation(complexType.AnyAttribute);
                    property.Documentation.AddRange(attributeDocs);

                    classModel.Properties.Add(property);
                }

                return(classModel);
            }

            var simpleType = type as XmlSchemaSimpleType;

            if (simpleType != null)
            {
                var restrictions = new List <RestrictionModel>();

                var typeRestriction = simpleType.Content as XmlSchemaSimpleTypeRestriction;
                if (typeRestriction != null)
                {
                    var enumFacets = typeRestriction.Facets.OfType <XmlSchemaEnumerationFacet>().ToList();
                    var isEnum     = (enumFacets.Count == typeRestriction.Facets.Count && enumFacets.Count != 0) ||
                                     (EnumTypes.Contains(typeRestriction.BaseTypeName.Name) && enumFacets.Any());
                    if (isEnum)
                    {
                        // we got an enum
                        var name = ToTitleCase(qualifiedName.Name);
                        if (namespaceModel != null)
                        {
                            name = namespaceModel.GetUniqueTypeName(name);
                        }

                        var enumModel = new EnumModel(_configuration)
                        {
                            Name          = name,
                            Namespace     = namespaceModel,
                            XmlSchemaName = qualifiedName,
                            XmlSchemaType = simpleType,
                        };

                        enumModel.Documentation.AddRange(docs);

                        foreach (var facet in enumFacets.DistinctBy(f => f.Value))
                        {
                            var value = new EnumValueModel
                            {
                                Name  = ToTitleCase(facet.Value).ToNormalizedEnumName(),
                                Value = facet.Value
                            };

                            var valueDocs = GetDocumentation(facet);
                            value.Documentation.AddRange(valueDocs);

                            var deprecated = facet.Annotation != null && facet.Annotation.Items.OfType <XmlSchemaAppInfo>()
                                             .Any(a => a.Markup.Any(m => m.Name == "annox:annotate" && m.HasChildNodes && m.FirstChild.Name == "jl:Deprecated"));
                            value.IsDeprecated = deprecated;

                            enumModel.Values.Add(value);
                        }

                        if (namespaceModel != null)
                        {
                            namespaceModel.Types[enumModel.Name] = enumModel;
                        }

                        if (!qualifiedName.IsEmpty)
                        {
                            Types[qualifiedName] = enumModel;
                        }

                        return(enumModel);
                    }

                    restrictions = GetRestrictions(typeRestriction.Facets.Cast <XmlSchemaFacet>(), simpleType).Where(r => r != null).Sanitize().ToList();
                }

                var simpleModelName = ToTitleCase(qualifiedName.Name);
                if (namespaceModel != null)
                {
                    simpleModelName = namespaceModel.GetUniqueTypeName(simpleModelName);
                }

                var simpleModel = new SimpleModel(_configuration)
                {
                    Name          = simpleModelName,
                    Namespace     = namespaceModel,
                    XmlSchemaName = qualifiedName,
                    XmlSchemaType = simpleType,
                    ValueType     = simpleType.Datatype.GetEffectiveType(_configuration),
                };

                simpleModel.Documentation.AddRange(docs);
                simpleModel.Restrictions.AddRange(restrictions);

                if (namespaceModel != null)
                {
                    namespaceModel.Types[simpleModel.Name] = simpleModel;
                }

                if (!qualifiedName.IsEmpty)
                {
                    Types[qualifiedName] = simpleModel;
                }

                return(simpleModel);
            }

            throw new Exception(string.Format("Cannot build declaration for {0}", qualifiedName));
        }
コード例 #14
0
 private static string GenerateEnumValue(EnumValueModel value)
 {
     return($@"        [EnumMember(Value = ""{value.Name}"")]
 {value.Name.ToPascalCase()},");
 }