private static void ProcessEnum(CodeEnum element, List <IntellisenseObject> list)
        {
            IntellisenseObject data = new IntellisenseObject
            {
                Name      = element.Name,
                IsEnum    = element.Kind == vsCMElement.vsCMElementEnum,
                FullName  = element.FullName,
                Namespace = GetNamespace(element),
                Summary   = GetSummary(element)
            };

            foreach (var codeEnum in element.Members.OfType <CodeVariable>())
            {
                var prop = new IntellisenseProperty
                {
                    Name           = codeEnum.Name,
                    Summary        = GetSummary(codeEnum),
                    InitExpression = GetInitializer(codeEnum.InitExpression)
                };

                data.Properties.Add(prop);
            }

            if (data.Properties.Count > 0)
            {
                list.Add(data);
            }
        }
        public void JavaScript_with_a_string_an_int_and_and_int_arrayproperty()
        {
            var result = new StringBuilder();

            var io = new IntellisenseObject(new[]
            {
                new IntellisenseProperty(_stringType, "AString"),
                new IntellisenseProperty(_int32Type, "AnInt"),
                new IntellisenseProperty(_int32ArrayType, "AnIntArray") { Summary = "ASummary"},
                new IntellisenseProperty(_simpleType, "TheSimple")
            })
            {
                FullName = "Foo.Primitives",
                Name = "Primitives",
                Namespace = "server"
            };
            IntellisenseWriter.WriteJavaScript(new[] { io }, result);

            result.ShouldBeCode(@"
var server = server || {};
/// <summary>The Primitives class as defined in Foo.Primitives</summary>
server.Primitives = function() {
/// <field name=""aString"" type=""String"">The AString property as defined in Foo.Primitives</field>
this.aString = '';
/// <field name=""anInt"" type=""Number"">The AnInt property as defined in Foo.Primitives</field>
this.anInt = 0;
/// <field name=""anIntArray"" type=""Number[]"">ASummary</field>
this.anIntArray = [];
/// <field name=""theSimple"" type=""Object"">The TheSimple property as defined in Foo.Primitives</field>
this.theSimple = { };
};");
        }
        private static void ProcessClass(CodeClass cc, CodeClass baseClass, List <IntellisenseObject> list, HashSet <CodeClass> underProcess)
        {
            string                       baseNs        = null;
            string                       baseClassName = null;
            string                       ns            = GetNamespace(cc);
            string                       className     = GetClassName(cc);
            HashSet <string>             references    = new HashSet <string>();
            IList <IntellisenseProperty> properties    = GetProperties(cc.Members, new HashSet <string>(), references).ToList();

            foreach (CodeElement member in cc.Members)
            {
                if (ShouldProcess(member))
                {
                    ProcessElement(member, list, underProcess);
                }
            }

            if (baseClass != null)
            {
                baseClassName = GetClassName(baseClass);
                baseNs        = GetNamespace(baseClass);
            }

            var intellisenseObject = new IntellisenseObject(properties.ToList(), references)
            {
                Namespace     = ns,
                Name          = className,
                BaseNamespace = baseNs,
                BaseName      = baseClassName,
                FullName      = cc.FullName,
                Summary       = GetSummary(cc)
            };

            list.Add(intellisenseObject);
        }
        public void TypeScript_with_a_string_an_int_and_and_int_arrayproperty()
        {
            var result = new StringBuilder();

            var io = new IntellisenseObject(new[]
            {
                new IntellisenseProperty(_stringType, "AString"),
                new IntellisenseProperty(_int32Type, "AnInt"),
                new IntellisenseProperty(_int32ArrayType, "AnIntArray") { Summary = "ASummary"},
                new IntellisenseProperty(_simpleType, "TheSimple")
            })
            {
                FullName = "Foo.Primitives",
                Name = "Primitives",
                Namespace = "server"
            };
            IntellisenseWriter.WriteTypeScript(new[] { io }, result);

            result.ShouldBeCode(@"
declare module server {
       interface Primitives {
        aString: string;
        anInt: number;
/** ASummary */
        anIntArray: number[];
        theSimple: server.Simple;
}
}");
        }
        public void TypeScript_with_on_string_property()
        {
            var result = new StringBuilder();

            var io = new IntellisenseObject(new[]
            {
                new IntellisenseProperty(_stringType, "AString")
            })
            {
                FullName = "Foo.Primitives",
                Name = "Primitives",
                Namespace = "server"
            };
            IntellisenseWriter.WriteTypeScript(new[] { io }, result);

            result.ShouldBeCode(@"
declare module server {
       interface Primitives {
        aString: string;
    }
}");
        }
        public void JavaScript_with_on_string_property()
        {
            var result = new StringBuilder();

            var io = new IntellisenseObject(new[]
            {
                new IntellisenseProperty(_stringType, "AString")
            })
            {
                FullName = "Foo.Primitives",
                Name = "Primitives",
                Namespace = "server"
            };
            IntellisenseWriter.WriteJavaScript(new[] { io }, result);

            result.ShouldBeCode(@"
var server = server || {};
/// <summary>The Primitives class as defined in Foo.Primitives</summary>
server.Primitives = function() {
/// <field name=""aString"" type=""String"">The AString property as defined in Foo.Primitives</field>
this.aString = '';
};");
        }
        private static void ProcessClass(CodeClass cc, List <IntellisenseObject> list)
        {
            var    references            = new HashSet <string>();
            var    properties            = GetProperties(cc.Members, new HashSet <string>(), references).ToList();
            var    dataContractAttribute = cc.Attributes.Cast <CodeAttribute>().Where(a => a.Name == "DataContract");
            string className             = cc.Name;
            string nsName = GetNamespace(cc);

            if (dataContractAttribute.Any())
            {
                var keyValues = dataContractAttribute.First().Children.OfType <CodeAttributeArgument>()
                                .ToDictionary(a => a.Name, a => (a.Value ?? "").Trim('\"', '\''));

                if (keyValues.ContainsKey("Name"))
                {
                    className = keyValues["Name"];
                }

                if (keyValues.ContainsKey("Namespace"))
                {
                    nsName = keyValues["Namespace"];
                }
            }

            if (properties.Any())
            {
                var intellisenseObject = new IntellisenseObject(properties, references.ToList())
                {
                    Namespace = nsName,
                    Name      = className,
                    FullName  = cc.FullName,
                    Summary   = GetSummary(cc)
                };

                list.Add(intellisenseObject);
            }
        }
 public void Init()
 {
     item = VSHost.TestSolution.FindProjectItem("CollectionModel.cs");
     theObject = IntellisenseParser.ProcessFile(item).First();
 }
        private static void ProcessClass(CodeClass cc, List<IntellisenseObject> list)
        {
            var references = new HashSet<string>();
            var properties = GetProperties(cc.Members, new HashSet<string>(), references).ToList();
            var dataContractAttribute = cc.Attributes.Cast<CodeAttribute>().Where(a => a.Name == "DataContract");
            string className = cc.Name;
            string nsName = GetNamespace(cc);

            if (dataContractAttribute.Any())
            {
                var keyValues = dataContractAttribute.First().Children.OfType<CodeAttributeArgument>()
                               .ToDictionary(a => a.Name, a => (a.Value ?? "").Trim('\"', '\''));

                if (keyValues.ContainsKey("Name"))
                    className = keyValues["Name"];

                if (keyValues.ContainsKey("Namespace"))
                    nsName = keyValues["Namespace"];
            }

            if (properties.Any())
            {
                var intellisenseObject = new IntellisenseObject(properties, references.ToList())
                {
                    Namespace = nsName,
                    Name = className,
                    FullName = cc.FullName,
                    Summary = GetSummary(cc)
                };

                list.Add(intellisenseObject);
            }
        }
        private static void ProcessEnum(CodeEnum element, List<IntellisenseObject> list)
        {
            IntellisenseObject data = new IntellisenseObject
            {
                Name = element.Name,
                IsEnum = element.Kind == vsCMElement.vsCMElementEnum,
                FullName = element.FullName,
                Namespace = GetNamespace(element),
                Summary = GetSummary(element)
            };

            foreach (var codeEnum in element.Members.OfType<CodeVariable>())
            {
                var prop = new IntellisenseProperty
                {
                    Name = codeEnum.Name,
                    Summary = GetSummary(codeEnum),
                    InitExpression = GetInitializer(codeEnum.InitExpression)
                };

                data.Properties.Add(prop);
            }

            if (data.Properties.Count > 0)
                list.Add(data);
        }
 public void Init()
 {
     _item = VSHost.TestSolution.FindProjectItem("Simple.cs");
     _theObject = IntellisenseParser.ProcessFile(_item).First();
 }
 public void Init()
 {
     item = VSHost.EnsureSolution(@"CodeGen\CodeGen.sln").FindProjectItem("CollectionModel.cs");
     theObject = IntellisenseParser.ProcessFile(item).First();
 }
        private static void ProcessClass(CodeClass cc, List<IntellisenseObject> list)
        {
            IntellisenseObject data = new IntellisenseObject
            {
                Name = cc.Name,
                FullName = cc.FullName,
                Properties = new List<IntellisenseProperty>()
            };

            foreach (CodeProperty property in cc.Members.OfType<CodeProperty>())
            {
                if (property.Attributes.Cast<CodeAttribute>().Any(a => a.Name == "IgnoreDataMember"))
                    continue;

                var prop = new IntellisenseProperty()
                {
                    Name = GetName(property),
                    Type = property.Type.AsString,
                    Summary = GetSummary(property)
                };

                data.Properties.Add(prop);
            }

            if (data.Properties.Count > 0)
                list.Add(data);
        }
 public void Init()
 {
     _item = VSHost.EnsureSolution(@"CodeGen\CodeGen.sln").FindProjectItem("Simple.cs");
     _theObject = IntellisenseParser.ProcessFile(_item).First();
 }
        private static void ProcessClass(CodeClass cc, CodeClass baseClass, List<IntellisenseObject> list, HashSet<CodeClass> underProcess)
        {
            string baseNs = null;
            string baseClassName = null;
            string ns = GetNamespace(cc);
            string className = GetClassName(cc);
            HashSet<string> references = new HashSet<string>();
            IList<IntellisenseProperty> properties = GetProperties(cc.Members, new HashSet<string>(), references).ToList();

            foreach (CodeElement member in cc.Members)
            {
                if (ShouldProcess(member))
                {
                    ProcessElement(member, list, underProcess);
                }
            }

            if (baseClass != null)
            {
                baseClassName = GetClassName(baseClass);
                baseNs = GetNamespace(baseClass);
            }

            if (properties.Any())
            {
                var intellisenseObject = new IntellisenseObject(properties.ToList(), references)
                {
                    Namespace = ns,
                    Name = className,
                    BaseNamespace = baseNs,
                    BaseName = baseClassName,
                    FullName = cc.FullName,
                    Summary = GetSummary(cc)
                };

                list.Add(intellisenseObject);
            }
        }
        public void TypeScript_with_a_string_and_simple_dictionary_property()
        {
            var result = new StringBuilder();

            var io = new IntellisenseObject(new[]
            {
                new IntellisenseProperty(_stringType, "AString"),
                new IntellisenseProperty(_stringDictionary, "ADictionary")
            })
            {
                FullName = "Foo",
                Name = "Bar",
                Namespace = "server"
            };
            IntellisenseWriter.WriteTypeScript(new[] { io }, result);

            result.ShouldBeCode(@"
                declare module server {
                       interface Bar {
                        aString: string;
                        aDictionary: { [index: string]: string };
                    }
                }"
            );
        }
        private static void ProcessClass(CodeClass cc, List<IntellisenseObject> list)
        {
            var properties = GetProperties(cc.Members, new HashSet<string>()).ToList();

            if (properties.Any())
            {
                var intellisenseObject = new IntellisenseObject(properties)
                {
                    Namespace = GetNamespace(cc),
                    Name = cc.Name,
                    FullName = cc.FullName,
                    Summary = GetSummary(cc),
                };

                list.Add(intellisenseObject);
            }
        }