← Back to branch summary

~ubuntu-branches/ubuntu/trusty/monodevelop/trusty-proposed

« back to all changes in this revision

Viewing changes to src/addins/AspNet/MonoDevelop.AspNet.Mvc/RazorGenerator/RazorHost.cs

  • Committer: Package Import Robot
  • Author(s): Jo Shields
  • Date: 2013-05-12 09:46:03 UTC
  • mto: This revision was merged to the branch mainline in revision 29.
  • Revision ID: package-import@ubuntu.com-20130512094603-mad323bzcxvmcam0
Tags: upstream-4.0.5+dfsg
Import upstream version 4.0.5+dfsg

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/addins/AspNet/MonoDevelop.AspNet.Mvc/RazorGenerator/RazorHost.cs
 
1
using System;
 
2
using System.CodeDom;
 
3
using System.CodeDom.Compiler;
 
4
using System.Collections.Generic;
 
5
using System.IO;
 
6
using System.Text;
 
7
using System.Web.Razor;
 
8
using System.Web.Razor.Generator;
 
9
using System.Web.Razor.Parser;
 
10
using System.Web.Razor.Parser.SyntaxTree;
 
11
using System.Web.WebPages;
 
12
 
 
13
namespace MonoDevelop.RazorGenerator
 
14
{
 
15
        delegate void RazorCodeTransformer (
 
16
                RazorHost host, CodeCompileUnit codeCompileUnit, CodeNamespace generatedNamespace,
 
17
                CodeTypeDeclaration generatedClass, CodeMemberMethod executeMethod);
 
18
 
 
19
        class RazorHost : RazorEngineHost
 
20
        {
 
21
                private readonly RazorCodeTransformer[] _transformers;
 
22
                private readonly string _fullPath;
 
23
                private readonly CodeDomProvider _codeDomProvider;
 
24
                private readonly CodeGeneratorOptions _codeGeneratorOptions;
 
25
                private string _defaultClassName;
 
26
 
 
27
                public RazorHost(string fullPath, CodeDomProvider codeDomProvider = null,
 
28
                                 RazorCodeTransformer[] transformers = null, CodeGeneratorOptions codeGeneratorOptions = null)
 
29
                        : base(RazorCodeLanguage.GetLanguageByExtension(".cshtml"))
 
30
                {
 
31
                        if (fullPath == null)
 
32
                        {
 
33
                                throw new ArgumentNullException("fullPath");
 
34
                        }
 
35
                        _transformers = transformers;
 
36
                        _fullPath = fullPath;
 
37
                        _codeDomProvider = codeDomProvider ?? new Microsoft.CSharp.CSharpCodeProvider ();
 
38
                        base.DefaultNamespace = "ASP";
 
39
                        EnableLinePragmas = true;
 
40
 
 
41
                        base.GeneratedClassContext = new GeneratedClassContext(
 
42
                                executeMethodName: GeneratedClassContext.DefaultExecuteMethodName,
 
43
                                writeMethodName: GeneratedClassContext.DefaultWriteMethodName,
 
44
                                writeLiteralMethodName: GeneratedClassContext.DefaultWriteLiteralMethodName,
 
45
                                writeToMethodName: "WriteTo",
 
46
                                writeLiteralToMethodName: "WriteLiteralTo",
 
47
                                templateTypeName: typeof(HelperResult).FullName,
 
48
                                defineSectionMethodName: "DefineSection",
 
49
                                beginContextMethodName: "BeginContext",
 
50
                                endContextMethodName: "EndContext"
 
51
                                )
 
52
                        {
 
53
                                ResolveUrlMethodName = "Href"
 
54
                        };
 
55
 
 
56
                        _codeGeneratorOptions = codeGeneratorOptions ?? new CodeGeneratorOptions () {
 
57
                                // HACK: we use true, even though razor uses false, to work around a mono bug where it omits the 
 
58
                                // line ending after "#line hidden", resulting in the unparseable "#line hiddenpublic"
 
59
                                BlankLinesBetweenMembers = true,
 
60
                                BracingStyle = "C",
 
61
                                // matches Razor built-in settings
 
62
                                IndentString = String.Empty,
 
63
                        };
 
64
                }
 
65
 
 
66
                public CodeDomProvider CodeDomProvider {
 
67
                        get { return _codeDomProvider; }
 
68
                }
 
69
 
 
70
                public CodeGeneratorOptions CodeGeneratorOptions {
 
71
                        get { return _codeGeneratorOptions; }
 
72
                }
 
73
 
 
74
                public string FullPath
 
75
                {
 
76
                        get { return _fullPath; }
 
77
                }
 
78
 
 
79
                public override string DefaultClassName
 
80
                {
 
81
                        get
 
82
                        {
 
83
                                return _defaultClassName ?? GetClassName();
 
84
                        }
 
85
                        set
 
86
                        {
 
87
                                if (!String.Equals(value, "__CompiledTemplate", StringComparison.OrdinalIgnoreCase))
 
88
                                {
 
89
                                        //  By default RazorEngineHost assigns the name __CompiledTemplate. We'll ignore this assignment
 
90
                                        _defaultClassName = value;
 
91
                                }
 
92
                        }
 
93
                }
 
94
 
 
95
                public Func<RazorHost,ParserBase> ParserFactory { get; set; }
 
96
 
 
97
                public RazorCodeGenerator CodeGenerator { get; set; }
 
98
 
 
99
                public bool EnableLinePragmas { get; set; }
 
100
 
 
101
                public string GenerateCode (out CompilerErrorCollection errors)
 
102
                {
 
103
                        errors = new CompilerErrorCollection ();
 
104
 
 
105
                        // Create the engine
 
106
                        RazorTemplateEngine engine = new RazorTemplateEngine(this);
 
107
 
 
108
                        // Generate code
 
109
                        GeneratorResults results = null;
 
110
                        try
 
111
                        {
 
112
                                Stream stream = File.OpenRead(_fullPath);
 
113
                                using (var reader = new StreamReader(stream, Encoding.Default, detectEncodingFromByteOrderMarks: true))
 
114
                                {
 
115
                                        results = engine.GenerateCode(reader, className: DefaultClassName, rootNamespace: DefaultNamespace, sourceFileName: _fullPath);
 
116
                                }
 
117
                        } catch (Exception e) {
 
118
                                errors.Add (new CompilerError (FullPath, 1, 1, null, e.ToString ()));
 
119
                                //Returning null signifies that generation has failed
 
120
                                return null;
 
121
                        }
 
122
 
 
123
                        // Output errors
 
124
                        foreach (RazorError error in results.ParserErrors) {
 
125
                                errors.Add (new CompilerError (FullPath, error.Location.LineIndex + 1, error.Location.CharacterIndex + 1, null, error.Message));
 
126
                        }
 
127
 
 
128
                        try
 
129
                        {
 
130
                                using (StringWriter writer = new StringWriter()) {
 
131
                                        //Generate the code
 
132
                                        writer.WriteLine("#pragma warning disable 1591");
 
133
                                        _codeDomProvider.GenerateCodeFromCompileUnit(results.GeneratedCode, writer, _codeGeneratorOptions);
 
134
                                        writer.WriteLine("#pragma warning restore 1591");
 
135
                                        return writer.ToString();
 
136
                                }
 
137
                        } catch (Exception e) {
 
138
                                errors.Add (new CompilerError (FullPath, 1, 1, null, e.ToString ()));
 
139
                                //Returning null signifies that generation has failed
 
140
                                return null;
 
141
                        }
 
142
                }
 
143
 
 
144
                public override void PostProcessGeneratedCode(CodeGeneratorContext context)
 
145
                {
 
146
                        if (_transformers == null) {
 
147
                                return;
 
148
                        }
 
149
                        foreach (var t in _transformers) {
 
150
                                t (this, context.CompileUnit, context.Namespace, context.GeneratedClass, context.TargetMethod);
 
151
                        }
 
152
                }
 
153
 
 
154
                public override RazorCodeGenerator DecorateCodeGenerator(RazorCodeGenerator incomingCodeGenerator)
 
155
                {
 
156
                        var codeGenerator = CodeGenerator ?? base.DecorateCodeGenerator(incomingCodeGenerator);
 
157
                        codeGenerator.GenerateLinePragmas = EnableLinePragmas;
 
158
                        return codeGenerator;
 
159
                }
 
160
 
 
161
                public override ParserBase DecorateCodeParser(ParserBase incomingCodeParser)
 
162
                {
 
163
                        return ParserFactory != null? ParserFactory (this) : base.DecorateCodeParser(incomingCodeParser);
 
164
                }
 
165
 
 
166
                protected virtual string GetClassName()
 
167
                {
 
168
                        string filename = Path.GetFileNameWithoutExtension(_fullPath);
 
169
                        return ParserHelpers.SanitizeClassName(filename);
 
170
                }
 
171
        }
 
172
}
 
 
b'\\ No newline at end of file'