GeneratorConf.cs

Go to the documentation of this file.

using System;
using System.Collections.Generic;
using System.Linq;

namespace CodeGen.generators
{
    public abstract class Generator
    {
        protected static bool UseTabs = true;

        public Dictionary<string, string> Generate(Package pkg)
        {
            var data = new Dictionary<string, string>();
            UseTabs = !pkg.UseSpaces;
            foreach (var @class in pkg.Classes)
            {
                if (@class?.Name != null)
                    data[@class.Name] = GenerateClass(@class) + '\n';
            }

            return data;
        }

        public virtual string GetIndent()
        {
            return "\t";
        }

        protected abstract string GenerateClass(Class @class);

        public abstract string GenerateField(Field field);

        public abstract string GenerateMethod(Method method);
    }

    public abstract class Normalizer
    {
        public virtual Package NormalizePackage(ref Package pkg)
        {
            if (pkg == null)
                return null;
            for (var i = 0; i < pkg.Classes?.Length; i++)
                NormalizeClass(ref pkg.Classes[i]);
            for (var i = 0; i < pkg.Packages?.Length; i++)
                if (pkg.Packages[i] != pkg)
                    NormalizePackage(ref pkg.Packages[i]);
            return pkg;
        }

        protected virtual Class NormalizeClass(ref Class @class)
        {
            if (@class == null)
                return null;
            for (var i = 0; i < @class.Fields?.Length; i++)
                NormalizeField(ref @class.Fields[i]);
            for (var i = 0; i < @class.Methods?.Length; i++)
                NormalizeMethod(ref @class.Methods[i]);
            for (var i = 0; i < @class.Classes?.Length; i++)
                NormalizeClass(ref @class.Classes[i]);
            return @class;
        }

        protected virtual Field NormalizeField(ref Field field)
        {
            field.Type = NormalizeType(field.Type);
            return field;
        }

        protected virtual Method NormalizeMethod(ref Method method)
        {
            method.Type = NormalizeType(method.Type);
            for (var i = 0; i < method.Parameters?.Length; i++)
                NormalizeParameter(method.Parameters[i]);
            return method;
        }

        protected virtual Parameter NormalizeParameter(Parameter parameter)
        {
            parameter.Type = NormalizeType(parameter.Type);
            return parameter;
        }

        protected abstract string NormalizeType(string type);
    }

    public abstract class Validator
    {
        private string[] AccessModifiers { get; } = {"", "public", "private", "protected", "default"};

        public virtual bool FieldIsValid(Field field)
        {
            if (field == null)
                return false;
            var isInvalid = string.IsNullOrWhiteSpace(field.Name);
            isInvalid |= string.IsNullOrWhiteSpace(field.Type);
            isInvalid |= string.IsNullOrWhiteSpace(field.Type);
            isInvalid |= field.Name.Any(char.IsWhiteSpace);
            isInvalid |= field.Type.Any(char.IsWhiteSpace);
            if (field.Access == null) return !isInvalid;
            isInvalid |= field.Access.Any(char.IsWhiteSpace);
            isInvalid |= !AccessModifiers.Any(field.Access.Equals);
            return !isInvalid;
        }
    }

    public struct Languange
    {
        public readonly Generator Generator;

        public readonly string Extension;

        public readonly string Comment;

        public readonly Normalizer Normalizer;

        private readonly int _indentSize;

        public Languange(Generator generator, string extension = "", string comment = "", Normalizer normalizer = null,
            int indentSize = 4)
        {
            Generator = generator;
            Extension = extension;
            Comment = comment;
            Normalizer = normalizer;
            _indentSize = indentSize;
        }
    }

    // ReSharper disable once ClassNeverInstantiated.Global
    public class GeneratorConf
    {
        public static readonly Package ExamplePkg = new Package
        {
            Name = "main",
            UseSpaces = true,
            Classes = new[]
            {
                new Class {Name = "Fruit"},
                new Class
                {
                    Name = "Apple",
                    Parent = "Fruit",
                    Fields = new[]
                    {
                        new Field
                        {
                            Access = "public",
                            Type = "string",
                            Name = "colour",
                            Default = "\"red\""
                        },
                        new Field
                        {
                            Access = "public",
                            Type = "string",
                            Static = true,
                            Name = "sort",
                            Default = "\"Golden\"",
                            Getter = true,
                            Setter = true
                        },
                        new Field
                        {
                            Access = "private",
                            Type = "int",
                            Name = "size",
                            Default = "1",
                            Getter = true
                        }
                    },
                    Methods = new[]
                    {
                        new Method
                        {
                            Access = "private",
                            Type = "",
                            Name = "print",
                            Parameters = new[]
                            {
                                new Parameter
                                {
                                    Name = "colour",
                                    Type = "string"
                                }
                            }
                        },
                        new Method
                        {
                            Access = "protected",
                            Type = "int",
                            Static = true,
                            Name = "getSizeValue"
                        },
                        new Method
                        {
                            Access = "public",
                            Type = "string",
                            Name = "getColorName",
                            Const = true
                        }
                    },
                    Classes = new[]
                    {
                        new Class
                        {
                            Access = "private",
                            Name = "Seed",
                            Fields = new[]
                            {
                                new Field
                                {
                                    Access = "public",
                                    Type = "int",
                                    Name = "size"
                                }
                            },
                            Methods = new[]
                            {
                                new Method
                                {
                                    Static = true,
                                    Access = "public",
                                    Type = "int",
                                    Name = "transform",
                                    Const = true
                                }
                            }
                        }
                    }
                },
            }
        };

        public static readonly Dictionary<string, Languange> Languanges = new Dictionary<string, Languange>
        {
            {"java", new Languange(new JavaGenerator(), "java", "/* {0} */", JavaNormalizer.GetNormalizer())},
            {"go", new Languange(new GoGenerator(), "go", "/* {0} */")},
            {"ruby", new Languange(new RubyGenerator(), "rb", "# {0}")},
            {"python", new Languange(new PythonGenerator(), "py", "# {0}\n")},
            {"vb", new Languange(new VbGenerator(), "vb", "' {0}\n", VbNormalizer.GetNormalizer())},
            {"csharp", new Languange(new CSharpGenerator(), "cs", "/* {0} */", CSharpNormalizer.GetNormalizer())},
            {"js_es6", new Languange(new Es6Generator(), "js", "/* {0} */")},
            {"groovy", new Languange(new GroovyGenerator(), "groovy", "/* {0} */")},
            {"cpp", new Languange(new CppGenerator(), "cpp", "/* {0} */")},
        };
        //{"es6", new Languange(new Es6Generator(), "es2015", "/* {0} */")},
//      {"js", new Languange(new Es6Generator(), "js5", "/* {0} */")},


        public static string GetIndent(bool tabs, int tabStop)
        {
            return tabs ? "\t" : new string(' ', tabStop);
        }

        public static string ShiftCode(string code, int num, string indent)
        {
            indent = string.Concat(Enumerable.Repeat(indent, num));
            return indent + code.Replace("\n", "\n" + indent);
        }

        public static string NormalizeLang(string lang)
        {
            if (lang == "js")
            {
                lang = "js_es6";
            }
            else if (lang == "c#" || lang == "cs")
            {
                lang = "csharp";
            }
            else if (lang == "yml")
            {
                lang = "yaml";
            }
            else if (lang == "c++")
            {
                lang = "cpp";
            }

            return lang;
        }

        public static Languange GetLanguage(string name)
        {
            name = NormalizeLang(name);
            Languange lang;
            try
            {
                lang = Languanges[name];
            }
            catch (Exception)
            {
                throw new IndexOutOfRangeException("this language doesn't exist");
            }

            return lang;
        }
    }
}