Ejemplo n.º 1
0
        public static string ParseRazor(string sourceRazor, string virtualPath, bool throws = false)
        {
            try
            {
                var extension = VirtualPathUtility.GetExtension(virtualPath);
                if (extension.IsEmpty() || extension != ".cshtml")
                {
                    return(string.Empty);
                }

                Trace.TraceInformation("Parsing razor... {0}", virtualPath);
                var    host = WebRazorHostFactory.CreateHostFromConfig(virtualPath);
                string code = GenerateCodeFromRazorString(host, sourceRazor, virtualPath);

                return(code);
            }
            catch (Exception ex)
            {
                Trace.TraceInformation("Error:... {0}", ex.Message);
                if (throws)
                {
                    throw;
                }

                return(ex.Message);
            }
        }
Ejemplo n.º 2
0
        public void CreateHostFromConfigIgnoresBaseTypeFromConfigIfPageIsAppStart()
        {
            // Arrange
            RazorWebSectionGroup config = new RazorWebSectionGroup()
            {
                Host  = null,
                Pages = new RazorPagesSection()
                {
                    PageBaseType = "System.Foo.Bar"
                }
            };

            WebRazorHostFactory.TypeFactory = name =>
                                              Assembly.GetExecutingAssembly().GetType(name, throwOnError: false);

            // Act
            WebPageRazorHost host = WebRazorHostFactory.CreateHostFromConfig(
                config,
                "/Foo/_appstart.cshtml",
                null
                );

            // Assert
            Assert.Equal(typeof(ApplicationStartPage).FullName, host.DefaultBaseClass);
        }
Ejemplo n.º 3
0
        public void CreateHostFromConfigMergesNamespacesFromConfigToHost()
        {
            // Arrange
            RazorWebSectionGroup config = new RazorWebSectionGroup()
            {
                Host  = null,
                Pages = new RazorPagesSection()
                {
                    Namespaces = new NamespaceCollection()
                    {
                        new NamespaceInfo("System"),
                        new NamespaceInfo("Foo")
                    }
                }
            };

            WebRazorHostFactory.TypeFactory = name => Assembly.GetExecutingAssembly().GetType(name, throwOnError: false);

            // Act
            WebPageRazorHost host = WebRazorHostFactory.CreateHostFromConfig(config, "/Foo/Bar.cshtml", null);

            // Assert
            Assert.True(host.NamespaceImports.Contains("System"));
            Assert.True(host.NamespaceImports.Contains("Foo"));
        }
Ejemplo n.º 4
0
        public void CreateHostFromConfigUsesFactorySpecifiedInConfig()
        {
            // Arrange
            RazorWebSectionGroup config = new RazorWebSectionGroup()
            {
                Host = new HostSection()
                {
                    FactoryType = typeof(TestFactory).FullName
                },
                Pages = null
            };

            WebRazorHostFactory.TypeFactory = name =>
                                              Assembly.GetExecutingAssembly().GetType(name, throwOnError: false);

            // Act
            WebPageRazorHost host = WebRazorHostFactory.CreateHostFromConfig(
                config,
                "/Foo/Bar.cshtml",
                null
                );

            // Assert
            Assert.IsType <TestHost>(host);
        }
Ejemplo n.º 5
0
        public void CreateHostFromConfigAppliesBaseTypeFromConfigToHost()
        {
            // Arrange
            RazorWebSectionGroup config = new RazorWebSectionGroup()
            {
                Host  = null,
                Pages = new RazorPagesSection()
                {
                    PageBaseType = "System.Foo.Bar"
                }
            };

            WebRazorHostFactory.TypeFactory = name =>
                                              Assembly.GetExecutingAssembly().GetType(name, throwOnError: false);

            // Act
            WebPageRazorHost host = WebRazorHostFactory.CreateHostFromConfig(
                config,
                "/Foo/Bar.cshtml",
                null
                );

            // Assert
            Assert.Equal("System.Foo.Bar", host.DefaultBaseClass);
        }
Ejemplo n.º 6
0
        RazorEngineHost CreateRazorHost(string fileName)
        {
            var projectFile = project.GetProjectFile(fileName);

            if (projectFile != null && projectFile.Generator == "RazorTemplatePreprocessor")
            {
                var h = MonoDevelop.RazorGenerator.RazorTemplatePreprocessor.CreateHost(fileName);
                h.DesignTimeMode = true;
                return(h);
            }

            string virtualPath = "~/Views/Default.cshtml";

            if (aspProject != null)
            {
                virtualPath = aspProject.LocalToVirtualPath(fileName);
            }

            WebPageRazorHost host = null;

            // Try to create host using web.config file
            var webConfigMap = new WebConfigurationFileMap();

            if (aspProject != null)
            {
                var vdm = new VirtualDirectoryMapping(aspProject.BaseDirectory.Combine("Views"), true, "web.config");
                webConfigMap.VirtualDirectories.Add("/", vdm);
            }
            Configuration configuration;

            try {
                configuration = WebConfigurationManager.OpenMappedWebConfiguration(webConfigMap, "/");
            } catch {
                configuration = null;
            }
            if (configuration != null)
            {
                var rws = configuration.GetSectionGroup(RazorWebSectionGroup.GroupName) as RazorWebSectionGroup;
                if (rws != null)
                {
                    host = WebRazorHostFactory.CreateHostFromConfig(rws, virtualPath, fileName);
                    host.DesignTimeMode = true;
                }
            }

            if (host == null)
            {
                host = new MvcWebPageRazorHost(virtualPath, fileName)
                {
                    DesignTimeMode = true
                };
                // Add default namespaces from Razor section
                host.NamespaceImports.Add("System.Web.Mvc");
                host.NamespaceImports.Add("System.Web.Mvc.Ajax");
                host.NamespaceImports.Add("System.Web.Mvc.Html");
                host.NamespaceImports.Add("System.Web.Routing");
            }

            return(host);
        }
        public void CreateHostPassesPhysicalPathOnToWebPageRazorHost() {
            // Act
            WebPageRazorHost host = new WebRazorHostFactory().CreateHost("~/Foo/Bar/Baz/Bar", @"C:\Foo.cshtml");

            // Assert
            Assert.AreEqual(@"C:\Foo.cshtml", host.PhysicalPath);
        }
        public void CreateHostReturnsWebPageHostWithWebPageAsBaseClassIfVirtualPathIsNormalPage() {
            // Act
            WebPageRazorHost host = new WebRazorHostFactory().CreateHost("~/Foo/Bar/Baz.cshtml", null);

            // Assert
            Assert.IsInstanceOfType(host, typeof(WebPageRazorHost));
            Assert.AreEqual(WebPageRazorHost.PageBaseClass, host.DefaultBaseClass);
        }
Ejemplo n.º 9
0
 public void CreateHostFromConfigRequiresNonEmptyVirtualPath()
 {
     ExceptionAssert.ThrowsArgNullOrEmpty(() => WebRazorHostFactory.CreateHostFromConfig(virtualPath: String.Empty,
                                                                                         physicalPath: "foo"), "virtualPath");
     ExceptionAssert.ThrowsArgNullOrEmpty(() => WebRazorHostFactory.CreateHostFromConfig(config: new RazorWebSectionGroup(),
                                                                                         virtualPath: String.Empty,
                                                                                         physicalPath: "foo"), "virtualPath");
 }
Ejemplo n.º 10
0
        public void CreateHostFromConfigReturnsWebCodeHostIfVirtualPathStartsWithAppCode()
        {
            // Act
            WebPageRazorHost host = WebRazorHostFactory.CreateHostFromConfigCore(null, "~/App_Code/Bar.cshtml", null);

            // Assert
            Assert.IsType <WebCodeRazorHost>(host);
        }
Ejemplo n.º 11
0
        public void CreateHostFromConfigUsesDefaultFactoryIfNoRazorWebSectionGroupFound()
        {
            // Act
            WebPageRazorHost host = WebRazorHostFactory.CreateHostFromConfigCore(null, "/Foo/Bar.cshtml", null);

            // Assert
            Assert.IsType <WebPageRazorHost>(host);
        }
Ejemplo n.º 12
0
        public void CreateHostPassesPhysicalPathOnToWebPageRazorHost()
        {
            // Act
            WebPageRazorHost host = new WebRazorHostFactory().CreateHost("~/Foo/Bar/Baz/Bar", @"C:\Foo.cshtml");

            // Assert
            Assert.Equal(@"C:\Foo.cshtml", host.PhysicalPath);
        }
Ejemplo n.º 13
0
 public void CreateHostFromConfigRequiresNonNullVirtualPath()
 {
     Assert.ThrowsArgumentNullOrEmptyString(() => WebRazorHostFactory.CreateHostFromConfig(virtualPath: null,
                                                                                           physicalPath: "foo"), "virtualPath");
     Assert.ThrowsArgumentNullOrEmptyString(() => WebRazorHostFactory.CreateHostFromConfig(config: new RazorWebSectionGroup(),
                                                                                           virtualPath: null,
                                                                                           physicalPath: "foo"), "virtualPath");
 }
        public void CreateHostReturnsWebPageHostWithStartPageAsBaseClassIfVirtualPathIsAppStart() {
            // Act
            WebPageRazorHost host = new WebRazorHostFactory().CreateHost("~/Foo/Bar/_appstart.cshtml", null);

            // Assert
            Assert.IsInstanceOfType(host, typeof(WebPageRazorHost));
            Assert.AreEqual(typeof(ApplicationStartPage).FullName, host.DefaultBaseClass);
        }
Ejemplo n.º 15
0
        public void CreateHostReturnsWebPageHostWithInitPageAsBaseClassIfVirtualPathIsPageStart()
        {
            // Act
            WebPageRazorHost host = new WebRazorHostFactory().CreateHost("~/Foo/Bar/_pagestart.cshtml", null);

            // Assert
            Assert.IsInstanceOfType(host, typeof(WebPageRazorHost));
            Assert.AreEqual(typeof(StartPage).FullName, host.DefaultBaseClass);
        }
        public void CreateHostReturnsWebPageHostWithInitPageAsBaseClassIfVirtualPathIsPageStart()
        {
            // Act
            WebPageRazorHost host = new WebRazorHostFactory().CreateHost("~/Foo/Bar/_pagestart.cshtml", null);

            // Assert
            Assert.IsType<WebPageRazorHost>(host);
            Assert.Equal(typeof(StartPage).FullName, host.DefaultBaseClass);
        }
Ejemplo n.º 17
0
        public void CreateHostReturnsWebPageHostWithWebPageAsBaseClassIfVirtualPathIsNormalPage()
        {
            // Act
            WebPageRazorHost host = new WebRazorHostFactory().CreateHost("~/Foo/Bar/Baz.cshtml", null);

            // Assert
            Assert.IsType <WebPageRazorHost>(host);
            Assert.Equal(WebPageRazorHost.PageBaseClass, host.DefaultBaseClass);
        }
Ejemplo n.º 18
0
        public void CreateHostReturnsWebPageHostWithStartPageAsBaseClassIfVirtualPathIsAppStart()
        {
            // Act
            WebPageRazorHost host = new WebRazorHostFactory().CreateHost("~/Foo/Bar/_appstart.cshtml", null);

            // Assert
            Assert.IsType <WebPageRazorHost>(host);
            Assert.Equal(typeof(ApplicationStartPage).FullName, host.DefaultBaseClass);
        }
        private Type GetTypeFromVirtualPathNoCache(string virtualPath)
        {
            // Use the Razor engine to generate source code from the view
            WebPageRazorHost host = WebRazorHostFactory.CreateHostFromConfig(virtualPath);
            string           code = GenerateCodeFromRazorTemplate(host, virtualPath);

            // Use Roslyn to compile the code into an assembly
            Assembly assembly = CompileCodeIntoAssembly(code, virtualPath);

            return(assembly.GetType(String.Format(CultureInfo.CurrentCulture, "{0}.{1}", host.DefaultNamespace, host.DefaultClassName)));
        }
Ejemplo n.º 20
0
 public void CreateHostFromConfigRequiresNonNullSectionGroup()
 {
     Assert.ThrowsArgumentNull(
         () =>
         WebRazorHostFactory.CreateHostFromConfig(
             config: (RazorWebSectionGroup)null,
             virtualPath: String.Empty,
             physicalPath: "foo"
             ),
         "config"
         );
 }
Ejemplo n.º 21
0
 private Type GetTypeFromVirtualPathNoCache(string virtualPath)
 {
     using (DoProfileStep($"{nameof(RoslynRazorViewEngine)}: Compiling {virtualPath}"))
     {
         OnCodeGenerationStarted();
         var args = new CompilingPathEventArgs(virtualPath, WebRazorHostFactory.CreateHostFromConfig(virtualPath));
         OnBeforeCompilePath(args);
         var host        = args.Host;
         var razorResult = RunRazorGenerator(virtualPath, host);
         var syntaxTree  = GetSyntaxTree(host, razorResult);
         var assembly    = CompileToAssembly(host, syntaxTree);
         return(assembly.GetType($"{host.DefaultNamespace}.{host.DefaultClassName}"));
     }
 }
Ejemplo n.º 22
0
        public void CreateHostFromConfigUsesDefaultFactoryIfNoHostSectionFound()
        {
            // Arrange
            RazorWebSectionGroup config = new RazorWebSectionGroup()
            {
                Host  = null,
                Pages = null
            };

            // Act
            WebPageRazorHost host = WebRazorHostFactory.CreateHostFromConfig(config, "/Foo/Bar.cshtml", null);

            // Assert
            Assert.IsType <WebPageRazorHost>(host);
        }
        public override SyntaxTree GetSyntaxTree(string sourcePath, Stream sourceStream, CSharpParseOptions parseOptions)
        {
            try
            {
                var viewFullPath    = sourcePath;
                var viewVirtualPath = GetRelativeUri(sourcePath, Compilation.CurrentDirectory.FullName);
                var viewConfig      = WebConfigurationManager.OpenMappedWebConfiguration(_configMap, viewVirtualPath);
                var razorConfig     = viewConfig.GetSectionGroup("system.web.webPages.razor") as RazorWebSectionGroup;
                var host            = razorConfig == null
                    ? WebRazorHostFactory.CreateDefaultHost(viewVirtualPath, viewFullPath)
                    : WebRazorHostFactory.CreateHostFromConfig(razorConfig, viewVirtualPath, viewFullPath);

                using (var rdr = new StreamReader(sourceStream, Compilation.Encoding, detectEncodingFromByteOrderMarks: true))
                    using (var provider = CodeDomProvider.CreateProvider("csharp"))
                        using (var generatedStream = new MemoryStream())
                            using (var generatedWriter = new StreamWriter(generatedStream, Compilation.Encoding))
                            {
                                var engine   = new RazorTemplateEngine(host);
                                var razorOut = engine.GenerateCode(rdr, null, null, viewFullPath);

                                // add the CompiledFromFileAttribute to the generated class
                                razorOut.GeneratedCode
                                .Namespaces.OfType <CodeNamespace>().FirstOrDefault()?
                                .Types.OfType <CodeTypeDeclaration>().FirstOrDefault()?
                                .CustomAttributes.Add(
                                    new CodeAttributeDeclaration(
                                        new CodeTypeReference(typeof(CompiledFromFileAttribute)),
                                        new CodeAttributeArgument(new CodePrimitiveExpression(viewFullPath))
                                        ));

                                var codeGenOptions = new CodeGeneratorOptions {
                                    VerbatimOrder = true, ElseOnClosing = false, BlankLinesBetweenMembers = false
                                };
                                provider.GenerateCodeFromCompileUnit(razorOut.GeneratedCode, generatedWriter, codeGenOptions);

                                // rewind
                                generatedWriter.Flush();
                                generatedStream.Position = 0;

                                return(base.GetSyntaxTree(sourcePath, generatedStream, parseOptions));
                            }
            }
            catch (Exception ex)
            {
                Compilation.Diagnostics.Add(Diagnostic.Create(Compilation.ViewGenerationFailed, Compilation.AsLocation(sourcePath), ex.ToString()));
                return(null);
            }
        }
Ejemplo n.º 24
0
        public void CreateHostFromConfigUsesDefaultFactoryIfNullFactoryType()
        {
            // Arrange
            RazorWebSectionGroup config = new RazorWebSectionGroup()
            {
                Host = new HostSection()
                {
                    FactoryType = null
                },
                Pages = null
            };

            // Act
            WebPageRazorHost host = WebRazorHostFactory.CreateHostFromConfig(config, "/Foo/Bar.cshtml", null);

            // Assert
            Assert.IsInstanceOfType(host, typeof(WebPageRazorHost));
        }
        private async Task BackgroundWorker()
        {
            foreach (var loader in _workItems.GetConsumingEnumerable(_cancellationToken))
            {
                if (_cancellationToken.IsCancellationRequested)
                {
                    loader.Result.SetCanceled();
                    continue;
                }
                try
                {
                    var originalText = await loader.OriginalLoader.LoadTextAndVersionAsync(_workspace, null, default(CancellationToken));

                    var viewFullPath    = originalText.FilePath;
                    var viewVirtualPath = GetRelativeUri(originalText.FilePath, _compilation.CurrentDirectory.FullName);
                    var viewConfig      = WebConfigurationManager.OpenMappedWebConfiguration(_configMap, viewVirtualPath);
                    var host            = viewConfig.GetSectionGroup("system.web.webPages.razor") is RazorWebSectionGroup razorConfig
                        ? WebRazorHostFactory.CreateHostFromConfig(razorConfig, viewVirtualPath, viewFullPath)
                        : WebRazorHostFactory.CreateDefaultHost(viewVirtualPath, viewFullPath);

                    // having this as a field would require the ASP.NET MVC dependency even for console apps...
                    RazorWorker worker = RazorWorker;
                    if (_cacheDirectory != null)
                    {
                        worker = CachedRazorWorker;
                    }

                    using (var stream = await worker(host, originalText))
                    {
                        var generatedText = TextAndVersion.Create(
                            SourceText.From(stream, _compilation.Encoding, _compilation.CscArgs.ChecksumAlgorithm, canBeEmbedded: originalText.Text.CanBeEmbedded, throwIfBinaryDetected: true),
                            originalText.Version,
                            originalText.FilePath);

                        loader.Result.TrySetResult(generatedText);
                    }
                }
                catch (Exception ex)
                {
                    loader.Result.TrySetException(ex);
                }
            }
        }
Ejemplo n.º 26
0
        public void CreateHostFromConfigThrowsInvalidOperationExceptionIfFactoryTypeNotFound()
        {
            // Arrange
            RazorWebSectionGroup config = new RazorWebSectionGroup()
            {
                Host = new HostSection()
                {
                    FactoryType = "Foo"
                },
                Pages = null
            };

            WebRazorHostFactory.TypeFactory = name => Assembly.GetExecutingAssembly().GetType(name, throwOnError: false);

            // Act
            Assert.Throws <InvalidOperationException>(
                () => WebRazorHostFactory.CreateHostFromConfig(config, "/Foo/Bar.cshtml", null),
                String.Format(RazorWebResources.Could_Not_Locate_FactoryType, "Foo"));
        }
        private void WrapCshtmlReader(string sourcePath, TextReader sourceReader, MemoryStream generatedStream)
        {
            var viewFullPath    = sourcePath;
            var viewVirtualPath = GetRelativeUri(sourcePath, _compilation.CurrentDirectory.FullName);
            var viewConfig      = WebConfigurationManager.OpenMappedWebConfiguration(_configMap, viewVirtualPath);
            var razorConfig     = viewConfig.GetSectionGroup("system.web.webPages.razor") as RazorWebSectionGroup;
            var host            = razorConfig == null
                ? WebRazorHostFactory.CreateDefaultHost(viewVirtualPath, viewFullPath)
                : WebRazorHostFactory.CreateHostFromConfig(razorConfig, viewVirtualPath, viewFullPath);

            using (var provider = CodeDomProvider.CreateProvider("csharp"))
                using (var generatedWriter = new StreamWriter(generatedStream, _compilation.Encoding, 1024, leaveOpen: true))
                {
                    var engine   = new RazorTemplateEngine(host);
                    var razorOut = engine.GenerateCode(sourceReader, null, null, viewFullPath);

                    // add the CompiledFromFileAttribute to the generated class
                    razorOut.GeneratedCode
                    .Namespaces.OfType <CodeNamespace>().FirstOrDefault()?
                    .Types.OfType <CodeTypeDeclaration>().FirstOrDefault()?
                    .CustomAttributes.Add(
                        new CodeAttributeDeclaration(
                            new CodeTypeReference(typeof(CompiledFromFileAttribute)),
                            new CodeAttributeArgument(new CodePrimitiveExpression(viewFullPath))
                            ));

                    var codeGenOptions = new CodeGeneratorOptions {
                        VerbatimOrder = true, ElseOnClosing = false, BlankLinesBetweenMembers = false
                    };
                    provider.GenerateCodeFromCompileUnit(razorOut.GeneratedCode, generatedWriter, codeGenOptions);

                    // rewind
                    generatedWriter.Flush();
                    generatedStream.Position = 0;
                }
        }
        private static WebPageRazorHost GetRazorWebPageRazorHost(string virtualPath, string physicalPath)
        {
            WebPageRazorHost webPageRazorHost = null;

            try
            {
                string physicalDirectory = physicalPath.Substring(0, physicalPath.Length - virtualPath.Length);
                string text = virtualPath.Replace('\\', '/');
                if (!text.StartsWith("/", StringComparison.Ordinal))
                {
                    text = "/" + text;
                }
                int num = text.LastIndexOf('/');
                text = text.Substring(0, (num == 0) ? 1 : num);
                WebConfigurationFileMap arg_62_0 = new WebConfigurationFileMap();
                VirtualDirectoryMapping mapping  = new VirtualDirectoryMapping(physicalDirectory, true);
                arg_62_0.VirtualDirectories.Add("/", mapping);
                Configuration configuration = WebConfigurationManager.OpenMappedWebConfiguration(arg_62_0, text);
                if (configuration != null)
                {
                    RazorWebSectionGroup razorWebSectionGroup = (RazorWebSectionGroup)configuration.GetSectionGroup(RazorWebSectionGroup.GroupName);
                    if (razorWebSectionGroup != null)
                    {
                        webPageRazorHost = WebRazorHostFactory.CreateHostFromConfig(razorWebSectionGroup, virtualPath, physicalPath);
                    }
                }
            }
            catch (Exception)
            {
            }
            if (webPageRazorHost == null)
            {
                webPageRazorHost = WebRazorHostFactory.CreateDefaultHost(virtualPath, physicalPath);
            }
            return(webPageRazorHost);
        }
Ejemplo n.º 29
0
        private CodeCompileUnit GenerateCodeByRazor(string inputFileContent)
        {
            var projectPath         = Path.GetDirectoryName(GetProject().FullName);
            var projectRelativePath = InputFilePath.Substring(projectPath.Length);
            var virtualPath         = VirtualPathUtility.ToAppRelative("~" + projectRelativePath);

            var config = WebConfigurationManager.OpenMappedWebConfiguration(new WebConfigurationFileMap {
                VirtualDirectories = { { "/", new VirtualDirectoryMapping(projectPath, true) } }
            }, projectRelativePath);

            var sectGroup = new RazorWebSectionGroup
            {
                Host = (HostSection)config.GetSection(HostSection.SectionName) ??
                       new HostSection {
                    FactoryType = typeof(MvcWebRazorHostFactory).AssemblyQualifiedName
                },
                Pages = (RazorPagesSection)config.GetSection(RazorPagesSection.SectionName)
            };

            var host = projectRelativePath.IndexOf("app_code", StringComparison.InvariantCultureIgnoreCase) >= 0 ?
                       /* Helper file:  */ new WebCodeRazorHost(virtualPath, InputFilePath) :
                       /* Regular view: */ WebRazorHostFactory.CreateHostFromConfig(sectGroup, virtualPath, InputFilePath);

            host.DefaultNamespace        = FileNameSpace;
            host.DefaultDebugCompilation = string.Equals(GetVSProject().Project.ConfigurationManager.ActiveConfiguration.ConfigurationName, "debug", StringComparison.InvariantCultureIgnoreCase);
            host.DefaultClassName        = Path.GetFileNameWithoutExtension(InputFilePath).Replace('.', '_');

            var res = new RazorTemplateEngine(host).GenerateCode(new StringReader(inputFileContent), null, null, InputFilePath);

            foreach (RazorError error in res.ParserErrors)
            {
                GeneratorError(4, error.Message, (uint)error.Location.LineIndex + 1, (uint)error.Location.CharacterIndex + 1);
            }

            return(res.ParserErrors.Count > 0 ? null : res.GeneratedCode);
        }
Ejemplo n.º 30
0
        static RazorEngineHost CreateRazorHost(RazorCSharpParserContext context)
        {
            if (context.Project != null)
            {
                var projectFile = context.Project.GetProjectFile(context.FileName);
                if (projectFile != null && projectFile.Generator == "RazorTemplatePreprocessor")
                {
                    return(new MonoDevelop.AspNet.Razor.Generator.PreprocessedRazorHost(context.FileName)
                    {
                        DesignTimeMode = true,
                        EnableLinePragmas = false,
                    });
                }
            }

            string virtualPath = "~/Views/Default.cshtml";

            if (context.AspProject != null)
            {
                virtualPath = context.AspProject.LocalToVirtualPath(context.FileName);
            }

            WebPageRazorHost host = null;

            // Try to create host using web.config file
            var webConfigMap = new WebConfigurationFileMap();

            if (context.AspProject != null)
            {
                var vdm = new VirtualDirectoryMapping(context.AspProject.Project.BaseDirectory.Combine("Views"), true, "web.config");
                webConfigMap.VirtualDirectories.Add("/", vdm);
            }
            Configuration configuration;

            try {
                configuration = WebConfigurationManager.OpenMappedWebConfiguration(webConfigMap, "/");
            } catch {
                configuration = null;
            }
            if (configuration != null)
            {
                //TODO: use our assemblies, not the project's
                var rws = configuration.GetSectionGroup(RazorWebSectionGroup.GroupName) as RazorWebSectionGroup;
                if (rws != null)
                {
                    host = WebRazorHostFactory.CreateHostFromConfig(rws, virtualPath, context.FileName);
                    host.DesignTimeMode = true;
                }
            }

            if (host == null)
            {
                host = new MvcWebPageRazorHost(virtualPath, context.FileName)
                {
                    DesignTimeMode = true
                };
                // Add default namespaces from Razor section
                host.NamespaceImports.Add("System.Web.Mvc");
                host.NamespaceImports.Add("System.Web.Mvc.Ajax");
                host.NamespaceImports.Add("System.Web.Mvc.Html");
                host.NamespaceImports.Add("System.Web.Routing");
            }

            return(host);
        }
Ejemplo n.º 31
0
        /// <summary>
        /// Function that builds the contents of the generated file based on the contents of the input file
        /// </summary>
        /// <param name="inputFileContent">Content of the input file</param>
        /// <returns>Generated file as a byte array</returns>
        protected override byte[] GenerateCode(string inputFileContent)
        {
            var references = GetVSProject().References;
            //add reference to our buildprovider and virtualpathprovider
            var buildprovAssembly = typeof(CompiledVirtualPathProvider).Assembly;

            if (references.Find(buildprovAssembly.GetName().Name) == null)
            {
                references.Add(buildprovAssembly.Location);
            }

            // Get the root folder of the project
            var appRoot = Path.GetDirectoryName(GetProject().FullName);

            // Determine the project-relative path
            string projectRelativePath = InputFilePath.Substring(appRoot.Length);

            // Turn it into a virtual path by prepending ~ and fixing it up
            string virtualPath = VirtualPathUtility.ToAppRelative("~" + projectRelativePath);

            var vdm  = new VirtualDirectoryMapping(appRoot, true);
            var wcfm = new WebConfigurationFileMap();

            wcfm.VirtualDirectories.Add("/", vdm);

            var config = WebConfigurationManager.OpenMappedWebConfiguration(wcfm, projectRelativePath);
            //System.Configuration.ConfigurationManager.OpenExeConfiguration(configFile);

            var sectGroup = new RazorWebSectionGroup
            {
                Host = (HostSection)config.GetSection(HostSection.SectionName) ??
                       new HostSection {
                    FactoryType = typeof(MvcWebRazorHostFactory).AssemblyQualifiedName
                },
                Pages = (RazorPagesSection)config.GetSection(RazorPagesSection.SectionName)
            };

            // Create the same type of Razor host that's used to process Razor files in App_Code
            var host = IsHelper ?
                       new WebCodeRazorHost(virtualPath, InputFilePath) :
                       WebRazorHostFactory.CreateHostFromConfig(sectGroup, virtualPath, InputFilePath);

            // Set the namespace to be the same as what's used by default for regular .cs files
            host.DefaultNamespace = FileNameSpace;

            host.NamespaceImports.Remove("WebMatrix.Data");
            host.NamespaceImports.Remove("WebMatrix.WebData");

            var systemWebPages = config.GetSection("system.web/pages") as PagesSection;

            if (systemWebPages != null)
            {
                foreach (NamespaceInfo ns in systemWebPages.Namespaces)
                {
                    if (!host.NamespaceImports.Contains(ns.Namespace))
                    {
                        host.NamespaceImports.Add(ns.Namespace);
                    }
                }
            }

            var compilationSection = config.GetSection("system.web/compilation") as CompilationSection;

            if (compilationSection != null)
            {
                foreach (AssemblyInfo assembly in compilationSection.Assemblies)
                {
                    if (assembly.Assembly != "*" && references.Find(assembly.Assembly) == null)
                    {
                        references.Add(assembly.Assembly);
                    }
                }
            }

            // Create a Razor engine and pass it our host
            var engine = new RazorTemplateEngine(host);

            // Generate code
            GeneratorResults results = null;

            try {
                using (TextReader reader = new StringReader(inputFileContent)) {
                    results = engine.GenerateCode(reader, null, null, InputFilePath);
                }
            }
            catch (Exception e) {
                this.GeneratorError(4, e.ToString(), 1, 1);
                //Returning null signifies that generation has failed
                return(null);
            }

            // Output errors
            foreach (RazorError error in results.ParserErrors)
            {
                GeneratorError(4, error.Message, (uint)error.Location.LineIndex + 1, (uint)error.Location.CharacterIndex + 1);
            }

            CodeDomProvider provider = GetCodeProvider();

            try {
                if (this.CodeGeneratorProgress != null)
                {
                    //Report that we are 1/2 done
                    this.CodeGeneratorProgress.Progress(50, 100);
                }

                using (StringWriter writer = new StringWriter(new StringBuilder())) {
                    CodeGeneratorOptions options = new CodeGeneratorOptions();
                    options.BlankLinesBetweenMembers = false;
                    options.BracingStyle             = "C";

                    // Add a GeneratedCode attribute to the generated class
                    CodeCompileUnit     generatedCode = results.GeneratedCode;
                    var                 ns            = generatedCode.Namespaces[0];
                    CodeTypeDeclaration generatedType = ns.Types[0];
                    generatedType.CustomAttributes.Add(
                        new CodeAttributeDeclaration(
                            new CodeTypeReference(typeof(GeneratedCodeAttribute)),
                            new CodeAttributeArgument(new CodePrimitiveExpression("MvcRazorClassGenerator")),
                            new CodeAttributeArgument(new CodePrimitiveExpression("1.0"))));

                    if (!IsHelper)
                    {
                        generatedType.CustomAttributes.Add(
                            new CodeAttributeDeclaration(
                                new CodeTypeReference(typeof(PageVirtualPathAttribute)),
                                new CodeAttributeArgument(new CodePrimitiveExpression(virtualPath))));
                    }

                    //Generate the code
                    provider.GenerateCodeFromCompileUnit(generatedCode, writer, options);

                    if (this.CodeGeneratorProgress != null)
                    {
                        //Report that we are done
                        this.CodeGeneratorProgress.Progress(100, 100);
                    }
                    writer.Flush();

                    // Save as UTF8
                    Encoding enc = Encoding.UTF8;

                    //Get the preamble (byte-order mark) for our encoding
                    byte[] preamble       = enc.GetPreamble();
                    int    preambleLength = preamble.Length;

                    //Convert the writer contents to a byte array
                    byte[] body = enc.GetBytes(writer.ToString());

                    //Prepend the preamble to body (store result in resized preamble array)
                    Array.Resize <byte>(ref preamble, preambleLength + body.Length);
                    Array.Copy(body, 0, preamble, preambleLength, body.Length);

                    //Return the combined byte array
                    return(preamble);
                }
            }
            catch (Exception e) {
                this.GeneratorError(4, e.ToString(), 1, 1);
                //Returning null signifies that generation has failed
                return(null);
            }
        }