?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Fixed IOC-96 "FactorySupport fails to create components if the factory instance is...
[castle.git] / MonoRail / Castle.MonoRail.Framework.Views.NVelocity / NVelocityViewEngine.cs
blobba7d453caab2b2a6ca29cb55478987fd46326012
1 // Copyright 2004-2007 Castle Project - http://www.castleproject.org/
2 //
3 // Licensed under the Apache License, Version 2.0 (the "License");
4 // you may not use this file except in compliance with the License.
5 // You may obtain a copy of the License at
6 //
7 // http://www.apache.org/licenses/LICENSE-2.0
8 //
9 // Unless required by applicable law or agreed to in writing, software
10 // distributed under the License is distributed on an "AS IS" BASIS,
11 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 // See the License for the specific language governing permissions and
13 // limitations under the License.
14
15 using NVelocity;
16 using NVelocity.App;
17 using NVelocity.Context;
18 using NVelocity.Runtime;
19
20 namespace Castle.MonoRail.Framework.Views.NVelocity
21 {
22 using System;
23 using System.IO;
24 using System.Collections;
25 using Castle.Core;
26 using Castle.MonoRail.Framework.Helpers;
27 using Castle.MonoRail.Framework.Views.NVelocity.JSGeneration;
28 using Commons.Collections;
29
30 /// <summary>
31 /// Implements a view engine using the popular Velocity syntax.
32 /// <para>
33 /// For details on the syntax, check the VTL Reference Guide
34 /// http://jakarta.apache.org/velocity/docs/vtl-reference-guide.html
35 /// </para>
36 /// </summary>
37 public class NVelocityViewEngine : ViewEngineBase, IInitializable
38 {
39 internal const String TemplateExtension = ".vm";
40 internal const String JsTemplateExtension = ".njs";
41
42 internal const String ServiceProvider = "service.provider";
43
44 private IServiceProvider provider;
45
46 protected VelocityEngine velocity = new VelocityEngine();
47
48 /// <summary>
49 /// Creates a new <see cref="NVelocityViewEngine"/> instance.
50 /// </summary>
51 public NVelocityViewEngine()
52 {
53 }
54
55 #region IInitializable implementation
56
57 public void Initialize()
58 {
59 ExtendedProperties props = new ExtendedProperties();
60
61 if (ViewSourceLoader.HasTemplate("nvelocity.properties"))
62 {
63 using(Stream stream = ViewSourceLoader.GetViewSource("nvelocity.properties").OpenViewStream())
64 {
65 props.Load(stream);
66 }
67 }
68
69 // Set up a custom directive manager
70 props.SetProperty("directive.manager",
71 "Castle.MonoRail.Framework.Views.NVelocity.CustomDirectiveManager; Castle.MonoRail.Framework.Views.NVelocity");
72
73 InitializeVelocityProperties(props);
74
75 velocity.SetApplicationAttribute("service.provider", provider);
76
77 velocity.Init(props);
78 }
79
80 #endregion
81
82 #region IServiceEnabledComponent implementation
83
84 public override void Service(IServiceProvider provider)
85 {
86 base.Service(provider);
87
88 this.provider = provider;
89 }
90
91 #endregion
92
93 #region IViewEngine implementation
94
95 /// <summary>
96 /// Gets a value indicating whether the view engine
97 /// support the generation of JS.
98 /// </summary>
99 /// <value>
100 /// <c>true</c> if JS generation is supported; otherwise, <c>false</c>.
101 /// </value>
102 public override bool SupportsJSGeneration
103 {
104 get { return true; }
105 }
106
107 /// <summary>
108 /// Gets the view file extension.
109 /// </summary>
110 /// <value>The view file extension.</value>
111 public override string ViewFileExtension
112 {
113 get { return ".vm"; }
114 }
115
116 /// <summary>
117 /// Gets the JS generator file extension.
118 /// </summary>
119 /// <value>The JS generator file extension.</value>
120 public override string JSGeneratorFileExtension
121 {
122 get { return ".njs"; }
123 }
124
125 /// <summary>
126 /// Evaluates whether the specified template exists.
127 /// </summary>
128 /// <param name="templateName"></param>
129 /// <returns><c>true</c> if it exists</returns>
130 public override bool HasTemplate(String templateName)
131 {
132 return ViewSourceLoader.HasTemplate(ResolveTemplateName(templateName));
133 }
134
135 /// <summary>
136 /// Processes the specified context.
137 /// </summary>
138 /// <param name="context">The context.</param>
139 /// <param name="controller">The controller.</param>
140 /// <param name="viewName">Name of the view.</param>
141 public override void Process(IRailsEngineContext context, Controller controller, String viewName)
142 {
143 IContext ctx = CreateContext(context, controller);
144
145 try
146 {
147 AdjustContentType(context);
148
149 bool hasLayout = controller.LayoutName != null;
150
151 TextWriter writer;
152
153 if (hasLayout)
154 {
155 // Because we are rendering within a layout we need to catch it first
156 writer = new StringWriter();
157 }
158 else
159 {
160 // No layout so render direct to the output
161 writer = context.Response.Output;
162 }
163
164 String view = ResolveTemplateName(viewName);
165
166 Template template = velocity.GetTemplate(view);
167
168 PreSendView(controller, template);
169
170 BeforeMerge(velocity, template, ctx);
171 template.Merge(ctx, writer);
172
173 PostSendView(controller, template);
174
175 if (hasLayout)
176 {
177 String contents = (writer as StringWriter).GetStringBuilder().ToString();
178 ProcessLayout(contents, controller, ctx, context);
179 }
180 }
181 catch(Exception ex)
182 {
183 if (Logger.IsErrorEnabled)
184 {
185 Logger.Error("Could not render view", ex);
186 }
187
188 throw;
189 }
190 }
191
192 /// <summary>
193 /// Processes the view - using the templateName to obtain the correct template
194 /// and writes the results to the System.TextWriter. No layout is applied!
195 /// </summary>
196 public override void Process(TextWriter output, IRailsEngineContext context, Controller controller, String viewName)
197 {
198 IContext ctx = CreateContext(context, controller);
199
200 AdjustContentType(context);
201
202 String view = ResolveTemplateName(viewName);
203
204 try
205 {
206 Template template = velocity.GetTemplate(view);
207
208 BeforeMerge(velocity, template, ctx);
209 template.Merge(ctx, output);
210 }
211 catch(Exception ex)
212 {
213 if (Logger.IsErrorEnabled)
214 {
215 Logger.Error("Could not render view", ex);
216 }
217
218 throw new RailsException("Could not render view: " + view, ex);
219 }
220 }
221
222 public override void ProcessPartial(TextWriter output, IRailsEngineContext context,
223 Controller controller, string partialName)
224 {
225 IContext ctx = CreateContext(context, controller);
226 String view = ResolveTemplateName(partialName);
227
228 try
229 {
230 Template template = velocity.GetTemplate(view);
231 template.Merge(ctx, output);
232 }
233 catch(Exception ex)
234 {
235 if (Logger.IsErrorEnabled)
236 {
237 Logger.Error("Could not render partial", ex);
238 }
239
240 throw new RailsException("Could not render partial " + view, ex);
241 }
242 }
243
244 public override object CreateJSGenerator(IRailsEngineContext context)
245 {
246 return new JSGeneratorDuck(new PrototypeHelper.JSGenerator(context));
247 }
248
249 public override void GenerateJS(TextWriter output, IRailsEngineContext context, Controller controller,
250 string templateName)
251 {
252 IContext ctx = CreateContext(context, controller);
253
254 object generator = CreateJSGenerator(context);
255
256 ctx.Put("page", generator);
257
258 AdjustJavascriptContentType(context);
259
260 String view = ResolveJSTemplateName(templateName);
261
262 try
263 {
264 Template template = velocity.GetTemplate(view);
265
266 StringWriter writer = new StringWriter();
267
268 template.Merge(ctx, writer);
269
270 output.WriteLine(generator);
271 }
272 catch(Exception ex)
273 {
274 if (Logger.IsErrorEnabled)
275 {
276 Logger.Error("Could not generate JS", ex);
277 }
278
279 throw new RailsException("Error generating JS. Template " + templateName, ex);
280 }
281 }
282
283 public override void ProcessContents(IRailsEngineContext context, Controller controller, String contents)
284 {
285 IContext ctx = CreateContext(context, controller);
286 AdjustContentType(context);
287
288 bool hasLayout = controller.LayoutName != null;
289
290 if (hasLayout)
291 {
292 ProcessLayout(contents, controller, ctx, context);
293 }
294 else
295 {
296 context.Response.Output.Write(contents);
297 }
298 }
299
300 #endregion
301
302 /// <summary>
303 /// Initializes basic velocity properties. The main purpose of this method is to
304 /// allow this logic to be overrided.
305 /// </summary>
306 /// <param name="props">The <see cref="ExtendedProperties"/> collection to populate.</param>
307 protected virtual void InitializeVelocityProperties(ExtendedProperties props)
308 {
309 velocity.SetApplicationAttribute(RuntimeConstants.RESOURCE_MANAGER_CLASS,
310 new CustomResourceManager(ViewSourceLoader));
311
312 LoadMacros(props);
313 }
314
315 /// <summary>
316 /// Resolves the template name into a velocity template file name.
317 /// </summary>
318 protected string ResolveTemplateName(string templateName)
319 {
320 if (Path.HasExtension(templateName))
321 {
322 return templateName;
323 }
324 else
325 {
326 return templateName + TemplateExtension;
327 }
328 }
329
330 /// <summary>
331 /// Resolves the template name into a velocity JS template file name.
332 /// </summary>
333 protected string ResolveJSTemplateName(string templateName)
334 {
335 if (Path.HasExtension(templateName))
336 {
337 return templateName;
338 }
339 else
340 {
341 return templateName + JsTemplateExtension;
342 }
343 }
344
345 /// <summary>
346 /// Resolves the layout template name into a velocity template file name.
347 /// </summary>
348 protected string ResolveLayoutTemplateName(string templateName)
349 {
350 if (templateName.StartsWith("/"))
351 {
352 // User is using a folder diferent than the layouts folder
353
354 return ResolveTemplateName(templateName);
355 }
356 else
357 {
358 return String.Format("{0}{1}{2}",
359 TemplateKeys.LayoutPath, Path.DirectorySeparatorChar,
360 ResolveTemplateName(templateName));
361 }
362 }
363
364 protected virtual void BeforeMerge(VelocityEngine velocityEngine, Template template, IContext context)
365 {
366 }
367
368 private void ProcessLayout(String contents, Controller controller, IContext ctx, IRailsEngineContext context)
369 {
370 String layout = ResolveLayoutTemplateName(controller.LayoutName);
371
372 BeforeApplyingLayout(layout, ref contents, controller, ctx, context);
373
374 RenderLayout(layout, contents, ctx, context, context.Response.Output);
375 }
376
377 protected virtual void BeforeApplyingLayout(string layout, ref string contents,
378 Controller controller, IContext ctx, IRailsEngineContext context)
379 {
380 }
381
382 protected void RenderLayout(string layoutName, string contents, IContext ctx, IRailsEngineContext context, TextWriter output)
383 {
384 try
385 {
386 ctx.Put(TemplateKeys.ChildContent, contents);
387
388 Template template = velocity.GetTemplate(layoutName);
389
390 BeforeMerge(velocity, template, ctx);
391
392 template.Merge(ctx, output);
393 }
394 catch(Exception ex)
395 {
396 if (context.Request.IsLocal)
397 {
398 SendErrorDetails(ex, context.Response.Output);
399 }
400 else
401 {
402 throw new RailsException("Error processing layout. Maybe the layout file does not exists? File: " + layoutName, ex);
403 }
404 }
405 }
406
407 private IContext CreateContext(IRailsEngineContext context, Controller controller)
408 {
409 Hashtable innerContext = new Hashtable(StringComparer.InvariantCultureIgnoreCase);
410
411 innerContext.Add(TemplateKeys.Controller, controller);
412 innerContext.Add(TemplateKeys.Context, context);
413 innerContext.Add(TemplateKeys.Request, context.Request);
414 innerContext.Add(TemplateKeys.Response, context.Response);
415 innerContext.Add(TemplateKeys.Session, context.Session);
416
417 if (controller.Resources != null)
418 {
419 foreach(String key in controller.Resources.Keys)
420 {
421 innerContext[key] = controller.Resources[key];
422 }
423 }
424
425 foreach(String key in context.Params.AllKeys)
426 {
427 if (key == null) continue; // Nasty bug?
428 object value = context.Params[key];
429 if (value == null) continue;
430 innerContext[key] = value;
431 }
432
433 // list from : http://msdn2.microsoft.com/en-us/library/hfa3fa08.aspx
434 object[] builtInHelpers =
435 new object[]
436 {
437 new StaticAccessorHelper<Byte>(),
438 new StaticAccessorHelper<SByte>(),
439 new StaticAccessorHelper<Int16>(),
440 new StaticAccessorHelper<Int32>(),
441 new StaticAccessorHelper<Int64>(),
442 new StaticAccessorHelper<UInt16>(),
443 new StaticAccessorHelper<UInt32>(),
444 new StaticAccessorHelper<UInt64>(),
445 new StaticAccessorHelper<Single>(),
446 new StaticAccessorHelper<Double>(),
447 new StaticAccessorHelper<Boolean>(),
448 new StaticAccessorHelper<Char>(),
449 new StaticAccessorHelper<Decimal>(),
450 new StaticAccessorHelper<String>(),
451 new StaticAccessorHelper<Guid>(),
452 new StaticAccessorHelper<DateTime>()
453 };
454
455 foreach(object helper in builtInHelpers)
456 {
457 innerContext[helper.GetType().GetGenericArguments()[0].Name] = helper;
458 }
459
460 if (controller.Helpers != null)
461 {
462 foreach (object key in controller.Helpers.Keys)
463 {
464 innerContext[key] = controller.Helpers[key];
465 }
466 }
467
468 // Adding flash as a collection and each individual item
469
470 if (context.Flash != null)
471 {
472 innerContext[Flash.FlashKey] = context.Flash;
473
474 foreach(DictionaryEntry entry in context.Flash)
475 {
476 if (entry.Value == null) continue;
477 innerContext[entry.Key] = entry.Value;
478 }
479 }
480
481 if (controller.PropertyBag != null)
482 {
483 foreach(DictionaryEntry entry in controller.PropertyBag)
484 {
485 if (entry.Value == null) continue;
486 innerContext[entry.Key] = entry.Value;
487 }
488 }
489
490 innerContext[TemplateKeys.SiteRoot] = context.ApplicationPath;
491
492 return new VelocityContext(innerContext);
493 }
494
495 private void SendErrorDetails(Exception ex, TextWriter writer)
496 {
497 writer.WriteLine("<pre>");
498 writer.WriteLine(ex);
499 writer.WriteLine("</pre>");
500 }
501
502 private void LoadMacros(ExtendedProperties props)
503 {
504 String[] macros = ViewSourceLoader.ListViews("macros");
505
506 ArrayList macroList = new ArrayList(macros);
507
508 if (macroList.Count > 0)
509 {
510 object libPropValue = props.GetProperty(RuntimeConstants.VM_LIBRARY);
511
512 if (libPropValue is ICollection)
513 {
514 macroList.AddRange((ICollection) libPropValue);
515 }
516 else if (libPropValue is string)
517 {
518 macroList.Add(libPropValue);
519 }
520
521 props.AddProperty(RuntimeConstants.VM_LIBRARY, macroList);
522 }
523
524 props.AddProperty(RuntimeConstants.VM_LIBRARY_AUTORELOAD, true);
525 }
526 }
527 }
Git import of castle svn