public DeclaredType(TypeIdentifier name, Namespace ns) : base(name) { Namespace = ns; Summary = new List<IComment>(); Interfaces = new List<IReferencable>(); }
private void AddMatch(string outputPath, string templatePath, ViewData data, Namespace ns) { var clone = data.Clone(); clone.Namespace = ns; AddMatch(outputPath, templatePath, clone); }
private void AddMatch(string outputPath, string templatePath, ViewData data, Namespace ns, DeclaredType type) { var clone = data.Clone(); clone.Type = type; AddMatch(outputPath, templatePath, clone, ns); }
public void MatchesSingleFilename() { var resolver = new PatternTemplateResolver(); var namespaces = new Namespace[0]; var results = resolver.Resolve("template.htm.spark", namespaces); results[0].OutputPath.ShouldEqual("template.htm"); results[0].TemplatePath.ShouldEqual("template.htm.spark"); }
public void ShouldResolveDirectoriesOfSameName() { var resolver = new PatternTemplateResolver(); var namespaces = new Namespace[0]; var results = resolver.Resolve("dir\\dir\\template.htm.spark", namespaces); results[0].OutputPath.ShouldEqual("dir\\dir\\template.htm"); results[0].TemplatePath.ShouldEqual("dir\\dir\\template.htm.spark"); }
public void CanWriteToOutputDirectory() { var transformer = MockRepository.GenerateMock<IPageWriter>(); var bulkTransformer = new BulkPageWriter(transformer); var namespaces = new Namespace[0]; bulkTransformer.CreatePagesFromDirectory(directory_sub, "output", namespaces); transformer.AssertWasCalled(x => x.CreatePages(directory_sub_oneSpark, "output", namespaces)); }
public void MatchesTemplateInDirectory() { var resolver = new PatternTemplateResolver(); var namespaces = new Namespace[0]; var results = resolver.Resolve("directory\\template.htm.spark", namespaces); results.Count.ShouldEqual(1); results[0].OutputPath.ShouldEqual("directory\\template.htm"); results[0].TemplatePath.ShouldEqual("directory\\template.htm.spark"); }
private void create_assemblies() { first_namespace = Namespace("First"); first_type = Type<First>(first_namespace); second_namespace = Namespace("Second"); second_type = Type<Second>(second_namespace); third_namespace = Namespace("Third"); third_type = Type<Third>(third_namespace); namespaces = new[] { first_namespace, second_namespace, third_namespace }; }
public void GeneratesOutputFromTemplate() { var generator = MockRepository.GenerateMock<IOutputGenerator>(); var writer = MockRepository.GenerateStub<IOutputWriter>(); var resolver = MockRepository.GenerateStub<IPatternTemplateResolver>(); var transformer = new PageWriter(generator, writer, resolver); var namespaces = new Namespace[0]; resolver.Stub(x => x.Resolve(null, null)) .IgnoreArguments() .Return(new List<TemplateMatch> { new TemplateMatch("simple.htm", "simple.spark", new ViewData()) }); transformer.CreatePages("simple.spark", "", namespaces); generator.AssertWasCalled( x => x.Convert(Arg.Is("simple.spark"), Arg<ViewData>.Is.Anything, Arg<string>.Is.Anything)); }
public void TransformsTemplatesInDirectories() { var generator = MockRepository.GenerateStub<IOutputGenerator>(); var writer = MockRepository.GenerateMock<IOutputWriter>(); var resolver = MockRepository.GenerateStub<IPatternTemplateResolver>(); var transformer = new PageWriter(generator, writer, resolver); var namespaces = new Namespace[0]; resolver.Stub(x => x.Resolve(null, null)) .IgnoreArguments() .Return(new List<TemplateMatch> { new TemplateMatch("directory\\test.htm", "", new ViewData()) }); generator.Stub(x => x.Convert(null, null)) .IgnoreArguments() .Return("content"); transformer.CreatePages("directory\\test.spark", "output", namespaces); writer.AssertWasCalled(x => x.WriteFile("output\\directory\\test.htm", "content")); }
public static DeclaredType Unresolved(TypeIdentifier typeIdentifier, Type type, Namespace ns) { var declaredType = new DeclaredType(typeIdentifier, ns) { IsResolved = false, representedType = type }; if (type.BaseType != null) declaredType.ParentType = Unresolved( Identifier.FromType(type.BaseType), type.BaseType, Namespace.Unresolved(Identifier.FromNamespace(type.BaseType.Namespace))); IEnumerable<Type> interfaces = GetInterfaces(type); foreach (Type face in interfaces) { declaredType.Interfaces.Add( Unresolved( Identifier.FromType(face), face, Namespace.Unresolved(Identifier.FromNamespace(face.Namespace)))); } return declaredType; }
public DeclaredType(TypeIdentifier name, Namespace ns) : base(name) { Namespace = ns; Interfaces = new List <IReferencable>(); }
public void Resolve(IDictionary <Identifier, IReferencable> referencables) { if (referencables.ContainsKey(identifier)) { IsResolved = true; IReferencable referencable = referencables[identifier]; var type = referencable as DeclaredType; if (type == null) { throw new InvalidOperationException("Cannot resolve to '" + referencable.GetType().FullName + "'"); } Namespace = type.Namespace; representedType = type.representedType; ParentType = type.ParentType; Interfaces = type.Interfaces; if (!Namespace.IsResolved) { Namespace.Resolve(referencables); } if (ParentType != null && !ParentType.IsResolved) { ParentType.Resolve(referencables); } foreach (IReferencable face in Interfaces) { if (!face.IsResolved) { face.Resolve(referencables); } } if (!Summary.IsResolved) { Summary.Resolve(referencables); } foreach (var method in Methods) { if (!method.IsResolved) { method.Resolve(referencables); } } foreach (var property in Properties) { if (!property.IsResolved) { property.Resolve(referencables); } } foreach (var ev in Events) { if (!ev.IsResolved) { ev.Resolve(referencables); } } foreach (var field in Fields) { if (!field.IsResolved) { field.Resolve(referencables); } } } else { ConvertToExternalReference(); } }
public static DeclaredType Unresolved(TypeIdentifier typeIdentifier, Type type, Namespace ns) { var declaredType = new DeclaredType(typeIdentifier, ns) { IsResolved = false, representedType = type }; if (type.BaseType != null) { declaredType.ParentType = Unresolved( Identifier.FromType(type.BaseType), type.BaseType, Namespace.Unresolved(Identifier.FromNamespace(type.BaseType.Namespace))); } IEnumerable <Type> interfaces = GetInterfaces(type); foreach (Type face in interfaces) { declaredType.Interfaces.Add( Unresolved( Identifier.FromType(face), face, Namespace.Unresolved(Identifier.FromNamespace(face.Namespace)))); } return(declaredType); }
public void when_template_directory_set_exclude_directory_from_output() { var generator = MockRepository.GenerateStub<IOutputGenerator>(); var writer = MockRepository.GenerateMock<IOutputWriter>(); var resolver = MockRepository.GenerateStub<IPatternTemplateResolver>(); var transformer = new PageWriter(generator, writer, resolver); var namespaces = new Namespace[0]; resolver.Stub(x => x.Resolve(null, null)) .IgnoreArguments() .Return(new List<TemplateMatch> { new TemplateMatch("someTemplatePath\\simple.htm", "someTemplatePath\\simple.spark", new ViewData()) }); generator.Stub(x => x.Convert(null, null, null)) .IgnoreArguments() .Return("content"); transformer.SetTemplatePath("someTemplatePath"); transformer.CreatePages("someTemplatePath\\simple.spark", "output", namespaces); writer.AssertWasCalled(x => x.WriteFile("output\\simple.htm", "content")); }
/// <summary> /// Initializes a new instance of the <see cref="DeclaredType"/> class. /// </summary> /// <param name="name"> /// The name. /// </param> /// <param name="ns"> /// The ns. /// </param> public DeclaredType(TypeIdentifier name, Namespace ns) : base(name) { this.Namespace = ns; this.Interfaces = new List<IReferencable>(); }
private void AddNamespace(List<Namespace> namespaces, DocumentedType association) { var ns = Identifier.FromNamespace(association.Type.Namespace); if (!namespaces.Exists(x => x.IsIdentifiedBy(ns))) { var doc = new Namespace(ns); matchedAssociations.Add(association.Name.CloneAsNamespace(), doc); namespaces.Add(doc); } }
public void shouldnt_parse_underscore_prefixed_spark_files() { var transformer = MockRepository.GenerateMock<IPageWriter>(); var bulkTransformer = new BulkPageWriter(transformer); var namespaces = new Namespace[0]; bulkTransformer.CreatePagesFromDirectory(directory, "output", namespaces); transformer.AssertWasNotCalled(x => x.CreatePages(directory_underscoreSpark, "output", namespaces)); }
public void should_pass_template_path_to_writer() { var transformer = MockRepository.GenerateMock<IPageWriter>(); var bulkTransformer = new BulkPageWriter(transformer); var namespaces = new Namespace[0]; bulkTransformer.CreatePagesFromDirectory(directory_sub, "output", namespaces); transformer.AssertWasCalled(x => x.SetTemplatePath(directory_sub)); }
public void Resolve(IDictionary <Identifier, IReferencable> referencables) { if (referencables.ContainsKey(identifier)) { IsResolved = true; IReferencable referencable = referencables[identifier]; var type = referencable as DeclaredType; if (type == null) { throw new InvalidOperationException("Cannot resolve to '" + referencable.GetType().FullName + "'"); } Namespace = type.Namespace; declaration = type.declaration; ParentType = type.ParentType; Interfaces = type.Interfaces; if (!Namespace.IsResolved) { Namespace.Resolve(referencables); } if (ParentType != null && !ParentType.IsResolved) { ParentType.Resolve(referencables); } foreach (IReferencable face in Interfaces) { if (!face.IsResolved) { face.Resolve(referencables); } } if (declaration != null && declaration.IsDefined(typeof(ObsoleteAttribute))) { ObsoleteReason = declaration.GetCustomAttribute <ObsoleteAttribute>().Message; } if (!Summary.IsResolved) { Summary.Resolve(referencables); } foreach (Method method in Methods) { if (!method.IsResolved) { method.Resolve(referencables); } } foreach (Property property in Properties) { if (!property.IsResolved) { property.Resolve(referencables); } } foreach (Event ev in Events) { if (!ev.IsResolved) { ev.Resolve(referencables); } } foreach (Enumeration enumeration in Enums) { if (!enumeration.IsResolved) { enumeration.Resolve(referencables); } } foreach (Field field in Fields) { if (!field.IsResolved) { field.Resolve(referencables); } } } else { ConvertToExternalReference(); } }
public static DeclaredType Unresolved(TypeIdentifier typeIdentifier, Namespace ns) { return new DeclaredType(typeIdentifier, ns) { IsResolved = false }; }
public static DeclaredType Unresolved(TypeIdentifier typeIdentifier, Type declaration, Namespace ns) { var declaredType = new DeclaredType(typeIdentifier, ns) { IsResolved = false, declaration = declaration }; if (declaration.BaseType != null) { declaredType.ParentType = Unresolved( IdentifierFor.Type(declaration.BaseType), declaration.BaseType, Namespace.Unresolved(IdentifierFor.Namespace(declaration.BaseType.Namespace))); } IEnumerable<Type> interfaces = GetInterfaces(declaration); foreach (Type face in interfaces) { declaredType.Interfaces.Add( Unresolved(IdentifierFor.Type(face), face, Namespace.Unresolved(IdentifierFor.Namespace(face.Namespace)))); } return declaredType; }
public static DeclaredType Unresolved(TypeIdentifier typeIdentifier, Type declaration, Namespace ns) { var declaredType = new DeclaredType(typeIdentifier, ns) { IsResolved = false, declaration = declaration }; if (declaration.BaseType != null) { declaredType.ParentType = Unresolved( IdentifierFor.Type(declaration.BaseType), declaration.BaseType, Namespace.Unresolved(IdentifierFor.Namespace(declaration.BaseType.Namespace))); } IEnumerable <Type> interfaces = GetInterfaces(declaration); foreach (Type face in interfaces) { declaredType.Interfaces.Add( Unresolved(IdentifierFor.Type(face), face, Namespace.Unresolved(IdentifierFor.Namespace(face.Namespace)))); } return(declaredType); }