MonoRail/Castle.MonoRail.Framework.Views.NVelocity/CustomDirectives/AbstractComponentDirective.cs

   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.Runtime.Parser.Node;
  16 using NVelocity.Runtime.Resource;
  17 using NVelocity.Runtime.Directive;
  18 using NVelocity.Runtime;
  19 using NVelocity.Exception;
  20 using NVelocity.Runtime.Parser;
  21 using IInternalContextAdapter = NVelocity.Context.IInternalContextAdapter;
  22 using Template = NVelocity.Template;
  23
  24 namespace Castle.MonoRail.Framework.Views.NVelocity.CustomDirectives
  25 {
  26         using System;
  27         using System.Collections.Specialized;
  28         using System.IO;
  29         using System.Text;
  30         using System.Collections;
  31
  32         using Castle.MonoRail.Framework;
  33
  34         /// <summary>
  35         /// Pendent
  36         /// </summary>
  37         public abstract class AbstractComponentDirective : Directive, IViewRenderer
  38         {
  39                 private readonly IViewComponentFactory viewComponentFactory;
  40
  41                 private String componentName;
  42                 private ViewComponent component;
  43                 private NVelocityViewContextAdapter contextAdapter;
  44                 private IViewEngine viewEngine;
  45                 private INode compNameNode;
  46
  47                 /// <summary>
  48                 /// Initializes a new instance of the <see cref="AbstractComponentDirective"/> class.
  49                 /// </summary>
  50                 /// <param name="viewComponentFactory">The view component factory.</param>
  51                 /// <param name="viewEngine">The view engine instance</param>
  52                 public AbstractComponentDirective(IViewComponentFactory viewComponentFactory, IViewEngine viewEngine)
  53                 {
  54                         this.viewComponentFactory = viewComponentFactory;
  55                         this.viewEngine = viewEngine;
  56                 }
  57
  58                 public override void Init(IRuntimeServices rs, IInternalContextAdapter context, INode node)
  59                 {
  60                         base.Init(rs, context, node);
  61
  62                         compNameNode = node.GetChild(0);
  63
  64                         if (compNameNode == null)
  65                         {
  66                                 String message = String.Format("You must specify the component name on the #{0} directive", Name);
  67                                 throw new ViewComponentException(message);
  68                         }
  69                 }
  70
  71                 public override bool Render(IInternalContextAdapter context, TextWriter writer, INode node)
  72                 {
  73                         componentName = compNameNode.FirstToken.Image;
  74
  75                         if (componentName == null)
  76                         {
  77                                 String message = String.Format("Could not obtain component name from the #{0} directive", Name);
  78                                 throw new ViewComponentException(message);
  79                         }
  80
  81                          if (componentName.StartsWith("$"))
  82                          {
  83                                 String nodeContent = compNameNode.Literal.Trim('"', '\'');
  84                                 SimpleNode inlineNode = rsvc.Parse(new StringReader(nodeContent), context.CurrentTemplateName, false);
  85
  86                                 inlineNode.Init(context, rsvc);
  87                                 componentName = (String) Evaluate(inlineNode, context);
  88                         }
  89
  90                         component = viewComponentFactory.Create(componentName);
  91
  92                         ASTDirective directiveNode = (ASTDirective) node;
  93                         IViewRenderer renderer = (IViewRenderer) directiveNode.Directive;
  94
  95                         contextAdapter = new NVelocityViewContextAdapter(componentName, node, viewEngine, renderer);
  96                         contextAdapter.Context = context;
  97
  98                         ProcessSubSections();
  99
 100                         INode bodyNode = null;
 101
 102                         IDictionary componentParams = CreateParameters(context, node);
 103
 104                         if (node.ChildrenCount > 0)
 105                         {
 106                                 bodyNode = node.GetChild(node.ChildrenCount - 1);
 107                         }
 108
 109                         contextAdapter.BodyNode = bodyNode;
 110                         contextAdapter.ComponentParams = componentParams;
 111                         contextAdapter.TextWriter = writer;
 112
 113                         IRailsEngineContext railsContext = MonoRailHttpHandler.CurrentContext;
 114
 115                         const string ViewComponentContextKey = "viewcomponent";
 116
 117                         try
 118                         {
 119                                 contextAdapter.ContextVars[ViewComponentContextKey] = component;
 120
 121                                 component.Init(railsContext, contextAdapter);
 122
 123                                 component.Render();
 124
 125                                 if (contextAdapter.ViewToRender != null)
 126                                 {
 127                                         return RenderComponentView(context, contextAdapter.ViewToRender, writer, contextAdapter);
 128                                 }
 129                         }
 130                         finally
 131                         {
 132                                 contextAdapter.ContextVars.Remove(ViewComponentContextKey);
 133                         }
 134
 135                         return true;
 136                 }
 137
 138                 public bool RenderComponentView(IInternalContextAdapter context, String viewToRender, TextWriter writer, NVelocityViewContextAdapter contextAdapter)
 139                 {
 140                         foreach(DictionaryEntry entry in contextAdapter.ContextVars)
 141                         {
 142                                 context.Put(entry.Key.ToString(), entry.Value);
 143                         }
 144
 145                         viewToRender = viewToRender + NVelocityViewEngine.TemplateExtension;
 146
 147                         CheckTemplateStack(context);
 148
 149                         String encoding = SetUpEncoding(context);
 150
 151                         Template template = GetTemplate(viewToRender, encoding);
 152
 153                         return RenderView(context, viewToRender, template, writer);
 154                 }
 155
 156                 protected virtual void ProcessSubSections()
 157                 {
 158                 }
 159
 160                 protected virtual IDictionary CreateParameters(IInternalContextAdapter context, INode node)
 161                 {
 162                         int childrenCount = node.ChildrenCount;
 163
 164                         if (childrenCount > 1)
 165                         {
 166                                 INode lastNode = node.GetChild(childrenCount - 1);
 167
 168                                 if (lastNode.Type == ParserTreeConstants.BLOCK)
 169                                 {
 170                                         childrenCount--;
 171                                 }
 172
 173                                 if (childrenCount > 1)
 174                                 {
 175                                         IDictionary dict = ProcessFirstParam(node, context, childrenCount);
 176
 177                                         if (dict != null)
 178                                         {
 179                                                 return dict;
 180                                         }
 181                                         else if (childrenCount > 2)
 182                                         {
 183                                                 return ProcessRemainingParams(childrenCount, node, context);
 184                                         }
 185                                 }
 186                         }
 187
 188                         return new Hashtable(0);
 189                 }
 190
 191                 protected string ComponentName
 192                 {
 193                         get { return componentName; }
 194                 }
 195
 196                 protected ViewComponent Component
 197                 {
 198                         get { return component; }
 199                 }
 200
 201                 protected NVelocityViewContextAdapter ContextAdapter
 202                 {
 203                         get { return contextAdapter; }
 204                 }
 205
 206                 private IDictionary ProcessRemainingParams(int childrenCount, INode node, IInternalContextAdapter context)
 207                 {
 208                         IDictionary entries = new HybridDictionary(true);
 209
 210                         for(int i = 2; i < childrenCount; i++)
 211                         {
 212                                 INode paramNode = node.GetChild(i);
 213
 214                                 string nodeContent = paramNode.Literal.TrimStart('"', '\'').TrimEnd('"', '\'');
 215
 216                                 string[] parts = nodeContent.Split(new char[] {'='}, 2, StringSplitOptions.RemoveEmptyEntries);
 217
 218                                 if (parts.Length == 2 && parts[1].IndexOf("$") != -1)
 219                                 {
 220                                         SimpleNode inlineNode = rsvc.Parse(new StringReader(parts[1]), context.CurrentTemplateName, false);
 221
 222                                         inlineNode.Init(context, rsvc);
 223
 224                                         entries[parts[0]] = Evaluate(inlineNode, context);
 225                                 }
 226                                 else if (parts.Length == 2)
 227                                 {
 228                                         entries[parts[0]] = parts[1];
 229                                 }
 230                                 else
 231                                 {
 232                                         entries[parts[0]] = String.Empty;
 233                                 }
 234                         }
 235
 236                         return entries;
 237                 }
 238
 239                 private object Evaluate(SimpleNode inlineNode, IInternalContextAdapter context)
 240                 {
 241                         ArrayList values = new ArrayList();
 242
 243                         for(int i=0; i < inlineNode.ChildrenCount; i++)
 244                         {
 245                                 INode node = inlineNode.GetChild(i);
 246
 247                                 if (node.Type == ParserTreeConstants.TEXT)
 248                                 {
 249                                         values.Add(((ASTText)node).Text);
 250                                 }
 251                                 else
 252                                 {
 253                                         values.Add(node.Value(context));
 254                                 }
 255                         }
 256
 257                         if (values.Count == 0)
 258                         {
 259                                 return null;
 260                         }
 261                         else if (values.Count == 1)
 262                         {
 263                                 return values[0];
 264                         }
 265                         else
 266                         {
 267                                 StringBuilder sb = new StringBuilder();
 268                                 foreach(object value in values)
 269                                 {
 270                                         sb.Append(value);
 271                                 }
 272                                 return sb.ToString();
 273                         }
 274                 }
 275
 276                 /// <summary>
 277                 /// Processes the first param.
 278                 /// first param can either be the literal string 'with' which means the user
 279                 /// is using the syntax #blockcomponent(ComponentName with "param1=value1" "param2=value2")
 280                 /// or it could be a dictionary string like:
 281                 /// #blockcomponent(ComponentName "#{ param1='value1', param2='value2' }")
 282                 /// anything different than that will throw an exception
 283                 /// </summary>
 284                 /// <param name="node">The node.</param>
 285                 /// <param name="context">The context.</param>
 286                 /// <param name="childrenCount">The children count.</param>
 287                 /// <returns></returns>
 288                 private IDictionary ProcessFirstParam(INode node, IInternalContextAdapter context, int childrenCount)
 289                 {
 290                         INode withNode = node.GetChild(1);
 291
 292                         String withName = withNode.FirstToken.Image;
 293
 294                         if (!"with".Equals(withName))
 295                         {
 296                                 IDictionary dict = withNode.Value(context) as IDictionary;
 297
 298                                 if (dict != null)
 299                                 {
 300                                         if (childrenCount > 2)
 301                                         {
 302                                                 String message = String.Format("A #{0} directive with a dictionary " +
 303                                                         "string param cannot have extra params - component {0}", componentName, Name);
 304                                                 throw new ViewComponentException(message);
 305                                         }
 306                                         return dict;
 307                                 }
 308                                 else
 309                                 {
 310                                         String message = String.Format("A #{0} directive with parameters must use " +
 311                                                         "the keyword 'with' - component {0}", componentName, Name);
 312                                         throw new ViewComponentException(message);
 313                                 }
 314                         }
 315
 316                         return null;
 317                 }
 318
 319                 private bool RenderView(IInternalContextAdapter context,
 320                                         String viewToRender, Template template, TextWriter writer)
 321                 {
 322                         try
 323                         {
 324                                 context.PushCurrentTemplateName(viewToRender);
 325                                 ((SimpleNode) template.Data).Render(context, writer);
 326                         }
 327                         catch(Exception e)
 328                         {
 329                                 if (e is MethodInvocationException)
 330                                 {
 331                                         throw;
 332                                 }
 333
 334                                 return false;
 335                         }
 336                         finally
 337                         {
 338                                 context.PopCurrentTemplateName();
 339                         }
 340
 341                         return true;
 342                 }
 343
 344                 private Template GetTemplate(String viewToRender, String encoding)
 345                 {
 346                         try
 347                         {
 348                                 return rsvc.GetTemplate(viewToRender, encoding);
 349                         }
 350                         catch(Exception)
 351                         {
 352                                 throw;
 353                         }
 354                 }
 355
 356                 private String SetUpEncoding(IInternalContextAdapter context)
 357                 {
 358                         Resource current = context.CurrentResource;
 359
 360                         String encoding = null;
 361
 362                         if (current != null)
 363                         {
 364                                 encoding = current.Encoding;
 365                         }
 366                         else
 367                         {
 368                                 encoding = (String) rsvc.GetProperty(RuntimeConstants.INPUT_ENCODING);
 369                         }
 370                         return encoding;
 371                 }
 372
 373                 private void CheckTemplateStack(IInternalContextAdapter context)
 374                 {
 375                         Object[] templateStack = context.TemplateNameStack;
 376
 377                         if (templateStack.Length >= rsvc.GetInt(RuntimeConstants.PARSE_DIRECTIVE_MAXDEPTH, 20))
 378                         {
 379                                 StringBuilder path = new StringBuilder();
 380
 381                                 for(int i = 0; i < templateStack.Length; ++i)
 382                                 {
 383                                         path.Append(" > " + templateStack[i]);
 384                                 }
 385
 386                                 throw new Exception("Max recursion depth reached (" + templateStack.Length + ")" + " File stack:" + path);
 387                         }
 388                 }
 389         }
 390 }