コード例 #1
0
        // Split: Split on ';'
        //	   Eg. Property values don't need to be split
        //
        // AllowItems: if false, item refs should not be treated as item refs!
        //	        it converts them to strings in the final expressionCollection
        //
        // AllowMetadata: same as AllowItems, for metadata
        public void Parse(string expression, ParseOptions options)
        {
            bool split      = (options & ParseOptions.Split) == ParseOptions.Split;
            bool allowItems = (options & ParseOptions.AllowItems) == ParseOptions.AllowItems;
            bool allowMd    = (options & ParseOptions.AllowMetadata) == ParseOptions.AllowMetadata;

            expression = expression.Replace('\\', Path.DirectorySeparatorChar);

            string [] parts;
            if (split)
            {
                parts = expression.Split(new char [] { ';' }, StringSplitOptions.RemoveEmptyEntries);
            }
            else
            {
                parts = new string [] { expression }
            };

            List <ArrayList> p1 = new List <ArrayList> (parts.Length);
            List <ArrayList> p2 = new List <ArrayList> (parts.Length);
            List <ArrayList> p3 = new List <ArrayList> (parts.Length);

            Prepare(p1, parts.Length);
            Prepare(p2, parts.Length);
            Prepare(p3, parts.Length);

            for (int i = 0; i < parts.Length; i++)
            {
                p1 [i] = SplitItems(parts [i], allowItems);
            }

            for (int i = 0; i < parts.Length; i++)
            {
                p2 [i] = new ArrayList();
                foreach (object o in p1[i])
                {
                    if (o is string)
                    {
                        p2 [i].AddRange(SplitProperties((string)o));
                    }
                    else
                    {
                        p2 [i].Add(o);
                    }
                }
            }

            for (int i = 0; i < parts.Length; i++)
            {
                p3 [i] = new ArrayList();
                foreach (object o in p2[i])
                {
                    if (o is string)
                    {
                        p3 [i].AddRange(SplitMetadata((string)o));
                    }
                    else
                    {
                        p3 [i].Add(o);
                    }
                }
            }

            CopyToExpressionCollection(p3, allowItems, allowMd);
        }

        void Prepare(List <ArrayList> l, int length)
        {
            for (int i = 0; i < length; i++)
            {
                l.Add(null);
            }
        }

        void CopyToExpressionCollection(List <ArrayList> lists, bool allowItems, bool allowMd)
        {
            for (int i = 0; i < lists.Count; i++)
            {
                foreach (object o in lists[i])
                {
                    if (o is string)
                    {
                        expressionCollection.Add(Utilities.Unescape((string)o));
                    }
                    else if (!allowItems && o is ItemReference)
                    {
                        expressionCollection.Add(((ItemReference)o).OriginalString);
                    }
                    else if (!allowMd && o is MetadataReference)
                    {
                        expressionCollection.Add(((MetadataReference)o).OriginalString);
                    }
                    else if (o is IReference)
                    {
                        expressionCollection.Add((IReference)o);
                    }
                }
                if (i < lists.Count - 1)
                {
                    expressionCollection.Add(";");
                }
            }
        }

        ArrayList SplitItems(string text, bool allowItems)
        {
            ArrayList phase1 = new ArrayList();
            Match     m;

            m = ItemRegex.Match(text);

            while (m.Success)
            {
                string        name = null, transform = null, separator = null;
                ItemReference ir;

                name = m.Groups [ItemRegex.GroupNumberFromName("itemname")].Value;

                if (m.Groups [ItemRegex.GroupNumberFromName("has_transform")].Success)
                {
                    transform = m.Groups [ItemRegex.GroupNumberFromName("transform")].Value;
                }

                if (m.Groups [ItemRegex.GroupNumberFromName("has_separator")].Success)
                {
                    separator = m.Groups [ItemRegex.GroupNumberFromName("separator")].Value;
                }

                ir = new ItemReference(text.Substring(m.Groups [0].Index, m.Groups [0].Length),
                                       name, transform, separator, m.Groups [0].Index, m.Groups [0].Length);
                phase1.Add(ir);
                m = m.NextMatch();
            }

            ArrayList phase2   = new ArrayList();
            int       last_end = -1;
            int       end      = text.Length - 1;

            foreach (ItemReference ir in phase1)
            {
                int a, b;

                a = last_end;
                b = ir.Start;

                if (b - a - 1 > 0)
                {
                    phase2.Add(text.Substring(a + 1, b - a - 1));
                }

                last_end = ir.End;
                phase2.Add(ir);
            }

            if (last_end < end)
            {
                phase2.Add(text.Substring(last_end + 1, end - last_end));
            }

            return(phase2);
        }

        ArrayList SplitProperties(string text)
        {
            ArrayList phase1 = new ArrayList();
            Match     m;

            m = PropertyRegex.Match(text);

            while (m.Success)
            {
                string            name = null;
                PropertyReference pr;

                name = m.Groups [PropertyRegex.GroupNumberFromName("name")].Value;

                pr = new PropertyReference(name, m.Groups [0].Index, m.Groups [0].Length);
                phase1.Add(pr);
                m = m.NextMatch();
            }

            ArrayList phase2   = new ArrayList();
            int       last_end = -1;
            int       end      = text.Length - 1;

            foreach (PropertyReference pr in phase1)
            {
                int a, b;

                a = last_end;
                b = pr.Start;

                if (b - a - 1 > 0)
                {
                    phase2.Add(text.Substring(a + 1, b - a - 1));
                }

                last_end = pr.End;
                phase2.Add(pr);
            }

            if (last_end < end)
            {
                phase2.Add(text.Substring(last_end + 1, end - last_end));
            }

            return(phase2);
        }

        ArrayList SplitMetadata(string text)
        {
            ArrayList phase1 = new ArrayList();
            Match     m;

            m = MetadataRegex.Match(text);

            while (m.Success)
            {
                string            name = null, meta = null;
                MetadataReference mr;

                if (m.Groups [MetadataRegex.GroupNumberFromName("name")].Success)
                {
                    name = m.Groups [MetadataRegex.GroupNumberFromName("name")].Value;
                }

                meta = m.Groups [MetadataRegex.GroupNumberFromName("meta")].Value;

                mr = new MetadataReference(text.Substring(m.Groups [0].Index, m.Groups [0].Length),
                                           name, meta, m.Groups [0].Index, m.Groups [0].Length);
                phase1.Add(mr);
                m = m.NextMatch();
            }

            ArrayList phase2   = new ArrayList();
            int       last_end = -1;
            int       end      = text.Length - 1;

            foreach (MetadataReference mr in phase1)
            {
                int a, b;

                a = last_end;
                b = mr.Start;

                if (b - a - 1 > 0)
                {
                    phase2.Add(text.Substring(a + 1, b - a - 1));
                }

                last_end = mr.End;
                phase2.Add(mr);
            }

            if (last_end < end)
            {
                phase2.Add(text.Substring(last_end + 1, end - last_end));
            }

            return(phase2);
        }
コード例 #2
0
        private void Run(string sourceCodePath, string wikiOutputPath)
        {
            if (!File.Exists(sourceCodePath))
            {
                throw new ArgumentException($"'{sourceCodePath}' does not exist.");
            }

            if (!Directory.Exists(wikiOutputPath))
            {
                throw new ArgumentException($"'{wikiOutputPath}' does not exist.");
            }

            Console.WriteLine($"classDiagram");
            Console.WriteLine($"");

            var baseClass     = string.Empty;
            var className     = string.Empty;
            var propertyNames = new List <string>();

            var summaryBuilder = new StringBuilder();

            summaryBuilder
            .AppendLine($"# Configuration Summary")
            .AppendLine()
            .AppendLine($"The following definitions are supported:")
            .AppendLine()
            .AppendLine($"| Definition | Summary |")
            .AppendLine($"|---|---|");

            void CloseClassDefinition()
            {
                if (string.IsNullOrEmpty(className))
                {
                    return;
                }

                summaryBuilder
                .AppendLine($"| [{className}](./{className}) | |");

                var builder = new StringBuilder();

                builder
                .AppendLine($"# {className} Details")
                .AppendLine()
                .AppendLine($"The {className} definition derives from the [{baseClass}](./{baseClass}) definition, and includes all of the base class properties.")
                .AppendLine()
                .AppendLine($"| PropertyName | Required | Description |")
                .AppendLine($"|---|---|---|");

                foreach (var propertyName in propertyNames)
                {
                    var required = propertyNames.IndexOf(propertyName) == 0
                        ? "Y"
                        : "N";

                    builder
                    .AppendLine($"| {propertyName} | {required} | |");
                }

                builder
                .AppendLine();

                File.WriteAllText(Path.Combine(wikiOutputPath, $"{className}.md"), builder.ToString());

                Console.WriteLine($"  {baseClass} <|-- {className}");
                Console.WriteLine($"  class {className} {{");

                foreach (var propertyName in propertyNames)
                {
                    Console.WriteLine($"    {propertyName}");
                }

                Console.WriteLine($"  }}");
                Console.WriteLine($"  link {className} \"https://github.com/AquaticInformatics/tabular-field-data-plugin/wiki/{className}\" \"See {className} details\"");
                Console.WriteLine($"  ");

                propertyNames.Clear();
            }

            foreach (var line in File.ReadAllLines(sourceCodePath))
            {
                var match = ClassRegex.Match(line);

                if (match.Success)
                {
                    CloseClassDefinition();

                    baseClass = SanitizeClassName(match.Groups["baseClass"].Value);
                    className = SanitizeClassName(match.Groups["derivedClass"].Value);

                    continue;
                }

                match = PropertyRegex.Match(line);

                if (!match.Success)
                {
                    continue;
                }

                var propertyName = match.Groups["propertyName"].Value;

                propertyNames.Add(propertyName);
            }

            CloseClassDefinition();

            File.WriteAllText(Path.Combine(wikiOutputPath, $"Summary.md"), summaryBuilder.ToString());
        }