?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Minor style changes
[castle.git] / MonoRail / Castle.MonoRail.Framework.Views.NVelocity / NVelocityViewEngine.cs
blobca868390c018b1605085ef29239d7cfd3b619521
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 /// Processes the specified context.
127 /// </summary>
128 /// <param name="context">The context.</param>
129 /// <param name="controller">The controller.</param>
130 /// <param name="viewName">Name of the view.</param>
131 public override void Process(IRailsEngineContext context, IController controller, String viewName)
132 {
133 IContext ctx = CreateContext(context, controller);
134
135 try
136 {
137 AdjustContentType(context);
138
139 bool hasLayout = controller.LayoutName != null;
140
141 TextWriter writer;
142
143 if (hasLayout)
144 {
145 // Because we are rendering within a layout we need to catch it first
146 writer = new StringWriter();
147 }
148 else
149 {
150 // No layout so render direct to the output
151 writer = context.Response.Output;
152 }
153
154 String view = ResolveTemplateName(viewName);
155
156 Template template = velocity.GetTemplate(view);
157
158 PreSendView(controller, template);
159
160 BeforeMerge(velocity, template, ctx);
161 template.Merge(ctx, writer);
162
163 PostSendView(controller, template);
164
165 if (hasLayout)
166 {
167 String contents = (writer as StringWriter).GetStringBuilder().ToString();
168 ProcessLayout(contents, controller, ctx, context);
169 }
170 }
171 catch(Exception ex)
172 {
173 if (Logger.IsErrorEnabled)
174 {
175 Logger.Error("Could not render view", ex);
176 }
177
178 throw;
179 }
180 }
181
182 /// <summary>
183 /// Processes the view - using the templateName to obtain the correct template
184 /// and writes the results to the System.TextWriter. No layout is applied!
185 /// </summary>
186 public override void Process(TextWriter output, IRailsEngineContext context, IController controller, String viewName)
187 {
188 IContext ctx = CreateContext(context, controller);
189
190 AdjustContentType(context);
191
192 String view = ResolveTemplateName(viewName);
193
194 try
195 {
196 Template template = velocity.GetTemplate(view);
197
198 BeforeMerge(velocity, template, ctx);
199 template.Merge(ctx, output);
200 }
201 catch (Exception ex)
202 {
203 if (Logger.IsErrorEnabled)
204 {
205 Logger.Error("Could not render view", ex);
206 }
207
208 throw new RailsException("Could not render view: " + view, ex);
209 }
210 }
211
212 public override void ProcessPartial(TextWriter output, IRailsEngineContext context,
213 IController controller, string partialName)
214 {
215 IContext ctx = CreateContext(context, controller);
216 String view = ResolveTemplateName(partialName);
217
218 try
219 {
220 Template template = velocity.GetTemplate(view);
221 template.Merge(ctx, output);
222 }
223 catch (Exception ex)
224 {
225 if (Logger.IsErrorEnabled)
226 {
227 Logger.Error("Could not render partial", ex);
228 }
229
230 throw new RailsException("Could not render partial " + view, ex);
231 }
232 }
233
234 public override object CreateJSGenerator(IRailsEngineContext context)
235 {
236 return new JSGeneratorDuck(new PrototypeHelper.JSGenerator(context));
237 }
238
239 public override void GenerateJS(TextWriter output, IRailsEngineContext context, IController controller,
240 string templateName)
241 {
242 IContext ctx = CreateContext(context, controller);
243
244 object generator = CreateJSGenerator(context);
245
246 ctx.Put("page", generator);
247
248 AdjustJavascriptContentType(context);
249
250 String view = ResolveJSTemplateName(templateName);
251
252 try
253 {
254 Template template = velocity.GetTemplate(view);
255
256 StringWriter writer = new StringWriter();
257
258 template.Merge(ctx, writer);
259
260 output.WriteLine(generator);
261 }
262 catch (Exception ex)
263 {
264 if (Logger.IsErrorEnabled)
265 {
266 Logger.Error("Could not generate JS", ex);
267 }
268
269 throw new RailsException("Error generating JS. Template " + templateName, ex);
270 }
271 }
272
273 public override void ProcessContents(IRailsEngineContext context, IController controller, String contents)
274 {
275 IContext ctx = CreateContext(context, controller);
276 AdjustContentType(context);
277
278 bool hasLayout = controller.LayoutName != null;
279
280 if (hasLayout)
281 {
282 ProcessLayout(contents, controller, ctx, context);
283 }
284 else
285 {
286 context.Response.Output.Write(contents);
287 }
288 }
289
290 #endregion
291
292 /// <summary>
293 /// Initializes basic velocity properties. The main purpose of this method is to
294 /// allow this logic to be overrided.
295 /// </summary>
296 /// <param name="props">The <see cref="ExtendedProperties"/> collection to populate.</param>
297 protected virtual void InitializeVelocityProperties(ExtendedProperties props)
298 {
299 velocity.SetApplicationAttribute(RuntimeConstants.RESOURCE_MANAGER_CLASS,
300 new CustomResourceManager(ViewSourceLoader));
301
302 LoadMacros(props);
303 }
304
305 /// <summary>
306 /// Resolves the layout template name into a velocity template file name.
307 /// </summary>
308 protected string ResolveLayoutTemplateName(string templateName)
309 {
310 if (templateName.StartsWith("/"))
311 {
312 // User is using a folder diferent than the layouts folder
313
314 return ResolveTemplateName(templateName);
315 }
316 else
317 {
318 return String.Format("{0}{1}{2}",
319 TemplateKeys.LayoutPath, Path.DirectorySeparatorChar,
320 ResolveTemplateName(templateName));
321 }
322 }
323
324 protected virtual void BeforeMerge(VelocityEngine velocityEngine, Template template, IContext context)
325 {
326 }
327
328 private void ProcessLayout(String contents, IController controller, IContext ctx, IRailsEngineContext context)
329 {
330 String layout = ResolveLayoutTemplateName(controller.LayoutName);
331
332 BeforeApplyingLayout(layout, ref contents, controller, ctx, context);
333
334 RenderLayout(layout, contents, ctx, context, context.Response.Output);
335 }
336
337 protected virtual void BeforeApplyingLayout(string layout, ref string contents,
338 IController controller, IContext ctx, IRailsEngineContext context)
339 {
340 }
341
342 protected void RenderLayout(string layoutName, string contents, IContext ctx, IRailsEngineContext context, TextWriter output)
343 {
344 try
345 {
346 ctx.Put(TemplateKeys.ChildContent, contents);
347
348 Template template = velocity.GetTemplate(layoutName);
349
350 BeforeMerge(velocity, template, ctx);
351
352 template.Merge(ctx, output);
353 }
354 catch (Exception ex)
355 {
356 if (context.Request.IsLocal)
357 {
358 SendErrorDetails(ex, context.Response.Output);
359 }
360 else
361 {
362 throw new RailsException("Error processing layout. Maybe the layout file does not exists? File: " + layoutName, ex);
363 }
364 }
365 }
366
367 private IContext CreateContext(IRailsEngineContext context, IController controller)
368 {
369 Hashtable innerContext = new Hashtable(StringComparer.InvariantCultureIgnoreCase);
370
371 innerContext.Add(TemplateKeys.Controller, controller);
372 innerContext.Add(TemplateKeys.Context, context);
373 innerContext.Add(TemplateKeys.Request, context.Request);
374 innerContext.Add(TemplateKeys.Response, context.Response);
375 innerContext.Add(TemplateKeys.Session, context.Session);
376
377 if (controller.Resources != null)
378 {
379 foreach (String key in controller.Resources.Keys)
380 {
381 innerContext[key] = controller.Resources[key];
382 }
383 }
384
385 foreach (String key in context.Params.AllKeys)
386 {
387 if (key == null) continue; // Nasty bug?
388 object value = context.Params[key];
389 if (value == null) continue;
390 innerContext[key] = value;
391 }
392
393 // list from : http://msdn2.microsoft.com/en-us/library/hfa3fa08.aspx
394 object[] builtInHelpers =
395 new object[]
396 {
397 new StaticAccessorHelper<Byte>(),
398 new StaticAccessorHelper<SByte>(),
399 new StaticAccessorHelper<Int16>(),
400 new StaticAccessorHelper<Int32>(),
401 new StaticAccessorHelper<Int64>(),
402 new StaticAccessorHelper<UInt16>(),
403 new StaticAccessorHelper<UInt32>(),
404 new StaticAccessorHelper<UInt64>(),
405 new StaticAccessorHelper<Single>(),
406 new StaticAccessorHelper<Double>(),
407 new StaticAccessorHelper<Boolean>(),
408 new StaticAccessorHelper<Char>(),
409 new StaticAccessorHelper<Decimal>(),
410 new StaticAccessorHelper<String>(),
411 new StaticAccessorHelper<Guid>(),
412 new StaticAccessorHelper<DateTime>()
413 };
414
415 foreach (object helper in builtInHelpers)
416 {
417 innerContext[helper.GetType().GetGenericArguments()[0].Name] = helper;
418 }
419
420 if (controller.Helpers != null)
421 {
422 foreach (object key in controller.Helpers.Keys)
423 {
424 innerContext[key] = controller.Helpers[key];
425 }
426 }
427
428 // Adding flash as a collection and each individual item
429
430 if (context.Flash != null)
431 {
432 innerContext[Flash.FlashKey] = context.Flash;
433
434 foreach (DictionaryEntry entry in context.Flash)
435 {
436 if (entry.Value == null) continue;
437 innerContext[entry.Key] = entry.Value;
438 }
439 }
440
441 if (controller.PropertyBag != null)
442 {
443 foreach (DictionaryEntry entry in controller.PropertyBag)
444 {
445 if (entry.Value == null) continue;
446 innerContext[entry.Key] = entry.Value;
447 }
448 }
449
450 innerContext[TemplateKeys.SiteRoot] = context.ApplicationPath;
451
452 return new VelocityContext(innerContext);
453 }
454
455 private void SendErrorDetails(Exception ex, TextWriter writer)
456 {
457 writer.WriteLine("<pre>");
458 writer.WriteLine(ex);
459 writer.WriteLine("</pre>");
460 }
461
462 private void LoadMacros(ExtendedProperties props)
463 {
464 String[] macros = ViewSourceLoader.ListViews("macros");
465
466 ArrayList macroList = new ArrayList(macros);
467
468 if (macroList.Count > 0)
469 {
470 object libPropValue = props.GetProperty(RuntimeConstants.VM_LIBRARY);
471
472 if (libPropValue is ICollection)
473 {
474 macroList.AddRange((ICollection)libPropValue);
475 }
476 else if (libPropValue is string)
477 {
478 macroList.Add(libPropValue);
479 }
480
481 props.AddProperty(RuntimeConstants.VM_LIBRARY, macroList);
482 }
483
484 props.AddProperty(RuntimeConstants.VM_LIBRARY_AUTORELOAD, true);
485 }
486 }
487 }
Git import of castle svn