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

public static void MakePartialAndRemoveCtor (RazorHost host, CodeCompileUnit codeCompileUnit, CodeNamespace generatedNamespace, CodeTypeDeclaration generatedClass, CodeMemberMethod executeMethod)

{

generatedClass.IsPartial = true;

// The generated class has a constructor in there by default.

generatedClass.Members.Remove (generatedClass.Members.OfType<CodeConstructor> ().Single ());

}

public static void AddGeneratedTemplateClassAttribute (RazorHost host, CodeCompileUnit codeCompileUnit, CodeNamespace generatedNamespace, CodeTypeDeclaration generatedClass, CodeMemberMethod executeMethod)

{

string tool = "RazorTemplatePreprocessor";

Version version = typeof (PreprocessedTemplateCodeTransformers).Assembly.GetName().Version;

generatedClass.CustomAttributes.Add(

new CodeAttributeDeclaration(typeof(System.CodeDom.Compiler.GeneratedCodeAttribute).FullName,

new CodeAttributeArgument(new CodePrimitiveExpression(tool)),

new CodeAttributeArgument(new CodePrimitiveExpression(version.ToString()))

));

}

static void AddComments (CodeTypeMember member, bool docComment, params string[] comments)

{

foreach (var c in comments) {

member.Comments.Add (new CodeCommentStatement (c, docComment));

}

public static void InjectBaseClass (RazorHost host, CodeCompileUnit codeCompileUnit, CodeNamespace generatedNamespace, CodeTypeDeclaration generatedClass, CodeMemberMethod executeMethod)

{

bool generateBaseClass = generatedClass.BaseTypes.Count == 0;

bool integrateHelpers = !generateBaseClass && generatedClass.BaseTypes [0].BaseType == "object";

if (!generateBaseClass && !integrateHelpers)

return;

if (generateBaseClass) {

var baseName = generatedClass.Name + "Base";

generatedClass.BaseTypes.Add (new CodeTypeReference (baseName));

var baseClass = new CodeTypeDeclaration (baseName) {

TypeAttributes = generatedClass.TypeAttributes | System.Reflection.TypeAttributes.Abstract,

};

AddComments (baseClass, false,

"NOTE: this is the default generated helper class. You may choose to extract it to a separate file ",

"in order to customize it or share it between multiple templates, and specify the template's base ",

"class via the @inherits directive."

);

generatedNamespace.Types.Add (baseClass);

baseClass.Members.Add (new CodeSnippetTypeMember (baseMembersString));

baseClass.Members.Add (new CodeSnippetTypeMember (baseExecuteMethodString));

} else {

generatedClass.BaseTypes [0].BaseType = "System.Object";

executeMethod.Attributes = (executeMethod.Attributes & (~MemberAttributes.AccessMask | ~MemberAttributes.Override))

| MemberAttributes.Private | MemberAttributes.Final;

generatedClass.Members.Add (new CodeSnippetTypeMember (baseMembersString));

}

/* rewrite:

public System.Web.WebPages.HelperResult foo (int i)

{

return new System.Web.WebPages.HelperResult(__razor_helper_writer => {

WriteLiteralTo(__razor_helper_writer, "<p>");

WriteTo(__razor_helper_writer, i);

WriteLiteralTo(__razor_helper_writer, "</p>\n");

});

}

to:

public static Action<TextWriter> foo (int i)

{

return __razor_helper_writer => {

__razor_helper_writer.Write("<p>");

WriteTo(__razor_helper_writer, i);

__razor_helper_writer.Write("</p>\n");

};

}

static string[,] replacements = new string [,] {

{ "public System.Web.WebPages.HelperResult " , "public static Action<System.IO.TextWriter> " },

{ "return new System.Web.WebPages.HelperResult(__razor_helper_writer" , "return __razor_helper_writer" },

{ "WriteLiteralTo(__razor_helper_writer," , "__razor_helper_writer.Write(" },

};

100

101

public static void SimplifyHelpers (RazorHost host, CodeCompileUnit codeCompileUnit, CodeNamespace generatedNamespace, CodeTypeDeclaration generatedClass, CodeMemberMethod executeMethod)

102

{

103

foreach (var method in generatedClass.Members.OfType<CodeSnippetTypeMember> ()) {

104

using (var writer = new System.IO.StringWriter (new System.Text.StringBuilder (method.Text.Length))) {

105

bool foundStart = false;

106

using (var reader = new System.IO.StringReader (method.Text)) {

107

bool lineHidden = false;

108

string line;

109

while ((line = reader.ReadLine ()) != null) {

110

if (!foundStart) {

111

if (line.StartsWith ("public System.Web.WebPages.HelperResult")) {

112

foundStart = true;

113

} else if (!string.IsNullOrWhiteSpace (line) && !line.StartsWith ("#line")) {

114

break;

115

}

116

}

117

if (line.StartsWith ("#line")) {

118

lineHidden = line == "#line hidden";

119

}

120

if (lineHidden && line == "});") {

121

writer.WriteLine ("};");

122

continue;

123

}

124

var len = replacements.GetLength (0);

125

for (int i = 0; i < len; i++) {

126

var bad = replacements[i,0];

127

if (line.StartsWith (bad)) {

128

line = replacements[i,1] + line.Substring (bad.Length);

129

}

130

}

131

writer.WriteLine (line);

132

}

133

}

134

if (foundStart) {

135

method.Text = writer.ToString ();

136

}

137

}

138

}

139

}

140

141

const string baseExecuteMethodString =

142

@" // This method is REQUIRED. The generated Razor subclass will override it with the generated code.

143

144

///<summary>Executes the template, writing output to the Write and WriteLiteral methods.</summary>.

145

///<remarks>Not intended to be called directly. Call the Generate method instead.</remarks>

146

public abstract void Execute ();

147

148

149

const string baseMembersString =

150

@" // This field is OPTIONAL, but used by the default implementation of Generate, Write and WriteLiteral

151

152

System.IO.TextWriter __razor_writer;

153

154

// This method is OPTIONAL

155

156

///<summary>Executes the template and returns the output as a string.</summary>

157

public string GenerateString ()

158

{

159

using (var sw = new System.IO.StringWriter ()) {

160

Generate (sw);

161

return sw.ToString();

162

}

163

}

164

165

// This method is OPTIONAL, you may choose to implement Write and WriteLiteral without use of __razor_writer

166

// and provide another means of invoking Execute.

167

168

///<summary>Executes the template, writing to the provided text writer.</summary>

169

public void Generate (System.IO.TextWriter writer)

170

{

171

__razor_writer = writer;

172

Execute ();

173

__razor_writer = null;

174

}

175

176

// This method is REQUIRED, but you may choose to implement it differently

177

178

///<summary>Writes literal values to the template output without HTML escaping them.</summary>

179

protected void WriteLiteral (string value)

180

{

181

__razor_writer.Write (value);

182

}

183

184

// This method is REQUIRED, but you may choose to implement it differently

185

186

///<summary>Writes values to the template output, HTML escaping them if necessary.</summary>

187

protected void Write (object value)

188

{

189

WriteTo (__razor_writer, value);

190

}

191

192

// This method is REQUIRED if the template uses any Razor helpers, but you may choose to implement it differently

193

194

///<summary>Invokes the action to write directly to the template output.</summary>

195

///<remarks>This is used for Razor helpers, which already perform any necessary HTML escaping.</remarks>

196

protected void Write (Action<System.IO.TextWriter> write)

197

{

198

write (__razor_writer);

199

}

200

201

// This method is REQUIRED if the template has any Razor helpers, but you may choose to implement it differently

202

203

///<remarks>Used by Razor helpers to HTML escape values.</remarks>

204

protected static void WriteTo (System.IO.TextWriter writer, object value)

205

{

206

if (value != null) {

207

writer.Write (System.Web.HttpUtility.HtmlEncode (value.ToString ()));

208

// NOTE: better version for .NET 4+, handles pre-escape HTML (IHtmlString)

209

// writer.Write (System.Web.HttpUtility.HtmlEncode (value));

210

}

211

}

212

213

}

214

}

b'\\ No newline at end of file'

Older »