?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Added a way to override message definition using external resources file.
[castle.git] / MonoRail / Castle.MonoRail.Framework.Views.NVelocity / NVelocityViewEngine.cs
blob61ea964add8254a682178fb3e9fd667056244fd0
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 template name into a velocity template file name.
347 /// </summary>
348 protected string ResolveTemplateName(string area, string templateName)
349 {
350 return String.Format("{0}{1}{2}",
351 area, Path.DirectorySeparatorChar,
352 ResolveTemplateName(templateName));
353 }
354
355 protected virtual void BeforeMerge(VelocityEngine velocityEngine, Template template, IContext context)
356 {
357 }
358
359 private void ProcessLayout(String contents, Controller controller, IContext ctx, IRailsEngineContext context)
360 {
361 String layout = ResolveTemplateName(TemplateKeys.LayoutPath, controller.LayoutName);
362
363 try
364 {
365 ctx.Put(TemplateKeys.ChildContent, contents);
366
367 Template template = velocity.GetTemplate(layout);
368
369 BeforeMerge(velocity, template, ctx);
370 template.Merge(ctx, context.Response.Output);
371 }
372 catch(Exception ex)
373 {
374 if (context.Request.IsLocal)
375 {
376 SendErrorDetails(ex, context.Response.Output);
377 return;
378 }
379 else
380 {
381 throw new RailsException("Could not obtain layout: " + layout, ex);
382 }
383 }
384 }
385
386 private IContext CreateContext(IRailsEngineContext context, Controller controller)
387 {
388 #if DOTNET2
389 Hashtable innerContext = new Hashtable(StringComparer.InvariantCultureIgnoreCase);
390 #else
391 Hashtable innerContext = new Hashtable(CaseInsensitiveHashCodeProvider.Default, CaseInsensitiveComparer.Default);
392 #endif
393
394 innerContext.Add(TemplateKeys.Controller, controller);
395 innerContext.Add(TemplateKeys.Context, context);
396 innerContext.Add(TemplateKeys.Request, context.Request);
397 innerContext.Add(TemplateKeys.Response, context.Response);
398 innerContext.Add(TemplateKeys.Session, context.Session);
399
400 if (controller.Resources != null)
401 {
402 foreach(String key in controller.Resources.Keys)
403 {
404 innerContext[key] = controller.Resources[key];
405 }
406 }
407
408 foreach(String key in context.Params.AllKeys)
409 {
410 if (key == null) continue; // Nasty bug?
411 object value = context.Params[key];
412 if (value == null) continue;
413 innerContext[key] = value;
414 }
415
416 #if DOTNET2
417 // list from : http://msdn2.microsoft.com/en-us/library/hfa3fa08.aspx
418 object[] builtInHelpers =
419 new object[]
420 {
421 new StaticAccessorHelper<Byte>(),
422 new StaticAccessorHelper<SByte>(),
423 new StaticAccessorHelper<Int16>(),
424 new StaticAccessorHelper<Int32>(),
425 new StaticAccessorHelper<Int64>(),
426 new StaticAccessorHelper<UInt16>(),
427 new StaticAccessorHelper<UInt32>(),
428 new StaticAccessorHelper<UInt64>(),
429 new StaticAccessorHelper<Single>(),
430 new StaticAccessorHelper<Double>(),
431 new StaticAccessorHelper<Boolean>(),
432 new StaticAccessorHelper<Char>(),
433 new StaticAccessorHelper<Decimal>(),
434 new StaticAccessorHelper<String>(),
435 new StaticAccessorHelper<Guid>(),
436 new StaticAccessorHelper<DateTime>()
437 };
438
439 foreach(object helper in builtInHelpers)
440 {
441 innerContext[helper.GetType().GetGenericArguments()[0].Name] = helper;
442 }
443 #endif
444
445 foreach(object key in controller.Helpers.Keys)
446 {
447 innerContext[key] = controller.Helpers[key];
448 }
449
450 // Adding flash as a collection and each individual item
451
452 if (context.Flash != null)
453 {
454 innerContext[Flash.FlashKey] = context.Flash;
455
456 foreach(DictionaryEntry entry in context.Flash)
457 {
458 if (entry.Value == null) continue;
459 innerContext[entry.Key] = entry.Value;
460 }
461 }
462
463 if (controller.PropertyBag != null)
464 {
465 foreach(DictionaryEntry entry in controller.PropertyBag)
466 {
467 if (entry.Value == null) continue;
468 innerContext[entry.Key] = entry.Value;
469 }
470 }
471
472 innerContext[TemplateKeys.SiteRoot] = context.ApplicationPath;
473
474 return new VelocityContext(innerContext);
475 }
476
477 private void SendErrorDetails(Exception ex, TextWriter writer)
478 {
479 writer.WriteLine("<pre>");
480 writer.WriteLine(ex);
481 writer.WriteLine("</pre>");
482 }
483
484 private void LoadMacros(ExtendedProperties props)
485 {
486 String[] macros = ViewSourceLoader.ListViews("macros");
487
488 ArrayList macroList = new ArrayList(macros);
489
490 if (macroList.Count > 0)
491 {
492 object libPropValue = props.GetProperty(RuntimeConstants.VM_LIBRARY);
493
494 if (libPropValue is ICollection)
495 {
496 macroList.AddRange((ICollection) libPropValue);
497 }
498 else if (libPropValue is string)
499 {
500 macroList.Add(libPropValue);
501 }
502
503 props.AddProperty(RuntimeConstants.VM_LIBRARY, macroList);
504 }
505
506 props.AddProperty(RuntimeConstants.VM_LIBRARY_AUTORELOAD, true);
507 }
508 }
509 }
Git import of castle svn