Experiments/IronPythonViewEngine/Castle.MonoRail.Views.IronView/IronPythonTemplateParser.cs

   1 // Copyright 2004-2008 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 namespace Castle.MonoRail.Views.IronView
  16 {
  17         using System;
  18         using System.Collections.Generic;
  19         using System.IO;
  20         using System.Text;
  21         using System.Xml;
  22
  23         public class IronPythonTemplateParser : ITemplateParser
  24         {
  25                 private IElementProcessor[] processors;
  26                 private Stack<IElementProcessor> processorStack = new Stack<IElementProcessor>();
  27
  28                 /// <summary>
  29                 /// Initializes a new instance of the <see cref="IronPythonTemplateParser"/> class.
  30                 /// </summary>
  31                 /// <param name="processors">The processors.</param>
  32                 public IronPythonTemplateParser(IElementProcessor[] processors)
  33                 {
  34                         this.processors = processors;
  35                 }
  36
  37                 public String CreateScriptBlock(TextReader reader, String viewName,
  38                                                 IServiceProvider serviceProvider, ITemplateEngine engine)
  39                 {
  40                         XmlTextReader xmlReader = new XmlTextReader(reader);
  41                         xmlReader.Namespaces = false;
  42                         xmlReader.WhitespaceHandling = WhitespaceHandling.All;
  43
  44                         DefaultContext context = new DefaultContext(viewName, xmlReader, serviceProvider, engine);
  45
  46                         ProcessReader(context, 0);
  47
  48                         return context.Script.ToString();
  49                 }
  50
  51                 public string CreateFunctionScriptBlock(StreamReader reader, string partialViewName, string methodName,
  52                                                                                                 IServiceProvider provider, ITemplateEngine engine, params String[] parameters)
  53                 {
  54                         XmlTextReader xmlReader = new XmlTextReader(reader);
  55                         xmlReader.Namespaces = false;
  56                         xmlReader.WhitespaceHandling = WhitespaceHandling.All;
  57
  58                         DefaultContext context = new DefaultContext(partialViewName, xmlReader, provider, engine);
  59
  60                         context.Script.Append("def ");
  61                         context.Script.Append(methodName);
  62                         context.Script.Append('(');
  63                         context.Script.Append("controller, context, request, response, session, output, flash, siteroot");
  64                         // context.Script.Append("output");
  65                         foreach(String param in parameters)
  66                         {
  67                                 context.Script.Append(',');
  68                                 context.Script.Append(param);
  69                         }
  70                         context.Script.Append(')');
  71                         context.Script.AppendLine(":");
  72
  73                         context.IncreaseIndentation();
  74
  75                         // context.AppendLineIndented("print 'hello'");
  76
  77                         ProcessReader(context, 0);
  78
  79                         context.DecreaseIndentation();
  80
  81                         context.Script.AppendLine();
  82
  83                         return context.Script.ToString();
  84                 }
  85
  86                 #region ITemplateParser
  87
  88                 public void ProcessReader(ITemplateContext context, int levelToStop)
  89                 {
  90                         XmlReader reader = context.Reader;
  91
  92                         while(reader.Read())
  93                         {
  94                                 switch(reader.NodeType)
  95                                 {
  96                                         case XmlNodeType.Comment:
  97                                                 break;
  98
  99                                         case XmlNodeType.ProcessingInstruction:
 100
 101                                                 if (IsCustomPI(context))
 102                                                 {
 103                                                         ProcessPI(context);
 104                                                 }
 105                                                 else
 106                                                 {
 107                                                         OutputCurrentElementAsContent(context);
 108                                                 }
 109                                                 break;
 110
 111                                         case XmlNodeType.Element:
 112
 113                                                 context.IncreaseDepth();
 114
 115                                                 if (IsCustomElement(reader))
 116                                                 {
 117                                                         ProcessCustomTag(context);
 118                                                 }
 119                                                 else
 120                                                 {
 121                                                         OutputCurrentElementAsContent(context);
 122                                                 }
 123
 124                                                 if (!reader.IsEmptyElement)
 125                                                 {
 126                                                         context.DecreaseDepth();
 127                                                 }
 128
 129                                                 break;
 130
 131                                         case XmlNodeType.EndElement:
 132
 133                                                 OutputCurrentElementAsContent(context);
 134
 135                                                 context.DecreaseDepth();
 136
 137                                                 if (context.CurrentElementDepth == levelToStop)
 138                                                 {
 139                                                         return;
 140                                                 }
 141
 142                                                 break;
 143
 144                                         case XmlNodeType.Text:
 145                                         case XmlNodeType.Whitespace:
 146                                                 OutputCurrentElementAsContent(context);
 147                                                 break;
 148
 149                                         case XmlNodeType.DocumentType:
 150                                                 OutputCurrentElementAsContent(context);
 151                                                 break;
 152                                 }
 153                         }
 154                 }
 155
 156                 public void OutputCurrentElementAsContent(ITemplateContext context)
 157                 {
 158                         OutputCurrentElementAsContent(context, null);
 159                 }
 160
 161                 public void OutputCurrentElementAsContent(ITemplateContext context, FilterAttribute filter)
 162                 {
 163                         context.AppendIndented("output.Write('");
 164
 165                         XmlReader reader = context.Reader;
 166                         StringBuilder script = context.Script;
 167
 168                         if (reader.NodeType == XmlNodeType.Element)
 169                         {
 170                                 if (reader.IsEmptyElement)
 171                                 {
 172                                         script.Append("<" + reader.LocalName);
 173                                         OutputAttributes(reader, script, filter);
 174                                         script.Append(" />");
 175                                 }
 176                                 else
 177                                 {
 178                                         script.Append("<");
 179                                         script.Append(reader.LocalName);
 180                                         OutputAttributes(reader, script, filter);
 181                                         script.Append(">");
 182                                 }
 183                         }
 184                         else if (reader.NodeType == XmlNodeType.EndElement)
 185                         {
 186                                 script.Append("</");
 187                                 script.Append(reader.LocalName);
 188                                 script.Append(">");
 189                         }
 190                         else if (reader.NodeType == XmlNodeType.ProcessingInstruction)
 191                         {
 192                                 script.Append("<?");
 193                                 script.Append(reader.LocalName);
 194                                 script.Append(' ');
 195                                 script.Append(reader.Value);
 196                                 script.Append(" ?>");
 197                         }
 198                         else if (reader.NodeType == XmlNodeType.Text ||
 199                                  reader.NodeType == XmlNodeType.Whitespace)
 200                         {
 201                                 script.Append(ConvertEscapes(reader.Value));
 202                         }
 203
 204                         script.AppendLine("')");
 205                 }
 206
 207                 #endregion
 208
 209                 private bool IsCustomPI(ITemplateContext context)
 210                 {
 211                         foreach(IElementProcessor processor in processors)
 212                         {
 213                                 if (processor.CanHandlePI(context.Reader.LocalName, context.Reader.Value))
 214                                 {
 215                                         processorStack.Push(processor);
 216
 217                                         return true;
 218                                 }
 219                         }
 220
 221                         return false;
 222                 }
 223
 224                 private void ProcessPI(ITemplateContext context)
 225                 {
 226                         processorStack.Pop().ProcessPI(this, context);
 227                 }
 228
 229                 private bool IsCustomElement(XmlReader reader)
 230                 {
 231                         foreach(IElementProcessor processor in processors)
 232                         {
 233                                 if (processor.CanHandleElement(this, reader))
 234                                 {
 235                                         processorStack.Push(processor);
 236
 237                                         return true;
 238                                 }
 239                         }
 240
 241                         return false;
 242                 }
 243
 244                 private void ProcessCustomTag(ITemplateContext context)
 245                 {
 246                         processorStack.Pop().ProcessElement(this, context);
 247                 }
 248
 249                 private void OutputAttributes(XmlReader reader, StringBuilder script, FilterAttribute filter)
 250                 {
 251                         if (!reader.HasAttributes) return;
 252
 253                         if (!reader.MoveToFirstAttribute()) return;
 254
 255                         do
 256                         {
 257                                 String name = reader.LocalName;
 258
 259                                 if (filter != null && !filter(name))
 260                                 {
 261                                         continue;
 262                                 }
 263
 264                                 script.Append(' ');
 265                                 script.Append(name);
 266                                 script.Append('=');
 267                                 script.Append('\"');
 268                                 script.Append(reader.Value);
 269                                 script.Append('\"');
 270
 271                         } while(reader.MoveToNextAttribute());
 272                 }
 273
 274                 private string ConvertEscapes(string value)
 275                 {
 276                         if (value == null || value == String.Empty) return String.Empty;
 277
 278                         // TODO: This can be greatly optimized
 279
 280                         return value.Replace("\t", "\\t").Replace("\n", "\\n").Replace("\r", "\\r");
 281                 }
 282         }
 283 }