MonoRail/Castle.MonoRail.Views.Brail/BrailPreProcessor.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.Brail
  16 {
  17         using System.Collections;
  18         using System.Collections.Generic;
  19         using System.IO;
  20         using Boo.Lang.Compiler;
  21         using Boo.Lang.Compiler.IO;
  22         using Boo.Lang.Compiler.Steps;
  23         using Framework;
  24
  25         public class BrailPreProcessor : AbstractCompilerStep
  26         {
  27                 public const string ClosingQuoteReplacement = "`^`";
  28                 public const string DoubleQuote = "\"";
  29                 private readonly static IDictionary separators = CreateSeparators();
  30                 private readonly BooViewEngine booViewEngine;
  31                 private readonly IDictionary inputToCode = new Hashtable();
  32
  33                 public BrailPreProcessor(BooViewEngine booViewEngine)
  34                 {
  35                         this.booViewEngine = booViewEngine;
  36                 }
  37
  38                 private static IDictionary CreateSeparators()
  39                 {
  40                         Hashtable seperators = new Hashtable();
  41                         seperators.Add("<?brail", "?>");
  42                         seperators.Add("<%", "%>");
  43                         return seperators;
  44                 }
  45
  46                 public string GetInputCode(ICompilerInput input)
  47                 {
  48                         return (string) inputToCode[input];
  49                 }
  50
  51                 public override void Run()
  52                 {
  53                         ArrayList processed = new ArrayList();
  54                         foreach(ICompilerInput input in Parameters.Input)
  55                         {
  56                                 //if input.Name.Contains("empty"):
  57                                 //      System.Diagnostics.Debugger.Break()
  58                                 using(TextReader reader = input.Open())
  59                                 {
  60                                         string code = reader.ReadToEnd();
  61                                         if (booViewEngine.ConditionalPreProcessingOnly(input.Name) == false ||
  62                                             ShouldPreProcess(code))
  63                                                 code = Booify(code);
  64                                         StringInput newInput = new StringInput(input.Name, code);
  65                                         inputToCode.Add(input, code);
  66                                         processed.Add(newInput);
  67                                 }
  68                         }
  69                         Parameters.Input.Clear();
  70                         foreach(StringInput input in processed)
  71                         {
  72                                 Parameters.Input.Add(input);
  73                         }
  74                 }
  75
  76                 private static bool ShouldPreProcess(string code)
  77                 {
  78                         foreach(DictionaryEntry entry in separators)
  79                         {
  80                                 if (code.Contains(entry.Key.ToString()))
  81                                         return true;
  82                         }
  83                         return false;
  84                 }
  85
  86                 public static string Booify(string code)
  87                 {
  88                         if (code.Length == 0)
  89                         {
  90                                 return "output string.Empty\r\n";
  91                         }
  92                         StringWriter buffer = new StringWriter();
  93                         int index = 0;
  94                         int lastIndex = 0;
  95                         string start, end;
  96                         DictionaryEntry seperators = GetSeperators(code);
  97                         start = seperators.Key.ToString();
  98                         end = seperators.Value.ToString();
  99
 100                         while(index != -1)
 101                         {
 102                                 index = code.IndexOf(start, lastIndex);
 103                                 if (index == -1)
 104                                         break;
 105                                 Output(buffer, code.Substring(lastIndex, index - lastIndex));
 106                                 int startReading = index + start.Length;
 107                                 lastIndex = code.IndexOf(end, startReading);
 108                                 if (lastIndex == -1)
 109                                         throw new MonoRailException("expected " + end);
 110                                 int lastIndexOffset = end.Length;
 111                                 if (code[lastIndex - 1] == '-')
 112                                 {
 113                                         --lastIndex;
 114
 115                                         if (EndTagEndsWithNewline(code, lastIndex + lastIndexOffset))
 116                                         {
 117                                                 lastIndexOffset += 2;
 118                                         }
 119                                         ++lastIndexOffset;
 120                                 }
 121                                 buffer.WriteLine(code.Substring(startReading, lastIndex - startReading));
 122                                 lastIndex += lastIndexOffset;
 123                         }
 124                         Output(buffer, code.Substring(lastIndex));
 125                         return buffer.ToString();
 126                 }
 127
 128                 private static bool EndTagEndsWithNewline(string code, int endIndex)
 129                 {
 130                         return code.Length > endIndex + 2 && code.Substring(endIndex + 1, 2) == "\r\n";
 131                 }
 132
 133                 private static void Output(StringWriter buffer, string code)
 134                 {
 135                         if (code.Length == 0)
 136                                 return;
 137                         IList<ExpressionPosition> expressions = GetExpressionsPositions(code);
 138                         if (expressions.Count == 0)
 139                         {
 140                                 OutputText(buffer, code);
 141                                 return;
 142                         }
 143
 144                         int start = 0;
 145                         foreach(ExpressionPosition position in expressions)
 146                         {
 147                                 string text = code.Substring(start, position.Start - start);
 148                                 OutputText(buffer, text);
 149                                 string expression = code.Substring(position.Start + 2, position.End - (position.Start + 2));
 150                                 OutputExpression(buffer, expression, position.ShouldEscape);
 151                                 start = position.End + 1;
 152                         }
 153                         string remainingText = code.Substring(start, code.Length - start);
 154                         OutputText(buffer, remainingText);
 155                 }
 156
 157                 private static void OutputText(StringWriter buffer, string code)
 158                 {
 159                         code = EscapeInitialAndClosingDoubleQuotes(code);
 160                         buffer.Write("output \"\"\"");
 161                         buffer.Write(code);
 162                         buffer.WriteLine("\"\"\"");
 163                 }
 164
 165                 private static void OutputExpression(TextWriter buffer, string code, bool shouldEscape)
 166                 {
 167                         if (shouldEscape)
 168                                 buffer.Write("OutputEscaped ");
 169                         else
 170                                 buffer.Write("output ");
 171                         buffer.WriteLine(code);
 172                 }
 173
 174                 private static string EscapeInitialAndClosingDoubleQuotes(string code)
 175                 {
 176                         if (code.StartsWith(DoubleQuote))
 177                                 code = ClosingQuoteReplacement + code.Substring(DoubleQuote.Length);
 178                         if (code.EndsWith(DoubleQuote))
 179                                 code = code.Substring(0, code.Length - DoubleQuote.Length) + ClosingQuoteReplacement;
 180                         return code;
 181                 }
 182
 183                 /// <summary>
 184                 /// Will find all the (outer most ${} expressions in the code, and return their positions).
 185                 /// Smart enough to figure out $${} escaping, but not much more
 186                 /// </summary>
 187                 private static IList<ExpressionPosition> GetExpressionsPositions(string code)
 188                 {
 189                         List<ExpressionPosition> bracesPositions = new List<ExpressionPosition>();
 190                         bool prevCharWasDollar = false;
 191                         bool prevCharWasBang = false;
 192                         for(int index = 0; index < code.Length; index++)
 193                         {
 194                                 if (code[index] == '{')
 195                                 {
 196                                         bracesPositions.Add(new ExpressionPosition(index - 1, -1, prevCharWasDollar || prevCharWasBang, prevCharWasBang));
 197                                 }
 198                                 if (code[index] == '}' && bracesPositions.Count > 0)
 199                                 {
 200                                         ExpressionPosition position = bracesPositions[bracesPositions.Count - 1];
 201                                         if (ParentExpressionIsNotValid(bracesPositions, bracesPositions.Count))
 202                                         {
 203                                                 bracesPositions.RemoveAt(bracesPositions.Count - 1);
 204                                         }
 205                                         else if (position.End == -1)
 206                                         {
 207                                                 position.End = index;
 208                                         }
 209                                 }
 210                                 //handles escaping expressions with $$ as well
 211                                 prevCharWasDollar = code[index] == '$' && !prevCharWasDollar;
 212                                 prevCharWasBang = code[index] == '!' && !prevCharWasBang;
 213                         }
 214                         bracesPositions.RemoveAll(delegate(ExpressionPosition obj) { return !obj.PrevCharWasDollarOrBang; });
 215                         return bracesPositions;
 216                 }
 217
 218                 private static bool ParentExpressionIsNotValid(List<ExpressionPosition> bracesPositions,
 219                                                                int index)
 220                 {
 221                         if (index - 2 < 0) return false;
 222                         ExpressionPosition parentExpression = bracesPositions[index - 2];
 223                         if (parentExpression.PrevCharWasDollarOrBang == false)
 224                                 return ParentExpressionIsNotValid(bracesPositions, index - 1);
 225                         return parentExpression.End == -1;
 226                 }
 227
 228                 private static DictionaryEntry GetSeperators(string code)
 229                 {
 230                         string start = null, end = null;
 231                         foreach(DictionaryEntry entry in separators)
 232                         {
 233                                 if (code.IndexOf(entry.Key as string, 0) != -1)
 234                                 {
 235                                         if (start != null && code.IndexOf(entry.Key as string) != -1)
 236                                                 continue; //handle a shorthanded seperator.
 237                                         // handle long seperator
 238                                         if (start != null && entry.Key.ToString().IndexOf(start as string) == -1)
 239                                         {
 240                                                 throw new MonoRailException("Can't mix seperators in one file. Found both " + start + " and " + entry.Key);
 241                                         }
 242                                         start = entry.Key.ToString();
 243                                         end = entry.Value.ToString();
 244                                 }
 245                         }
 246
 247                         if (start == null) //default, doesn't really matter, since it won't be used.
 248                         {
 249                                 foreach(DictionaryEntry entry in separators)
 250                                 {
 251                                         return entry;
 252                                 }
 253                         }
 254                         return new DictionaryEntry(start, end);
 255                 }
 256
 257                 public static string UnescapeInitialAndClosingDoubleQuotes(string code)
 258                 {
 259                         if (code.StartsWith(ClosingQuoteReplacement))
 260                                 code = DoubleQuote + code.Substring(ClosingQuoteReplacement.Length);
 261                         if (code.EndsWith(ClosingQuoteReplacement))
 262                                 code = code.Substring(0, code.Length - ClosingQuoteReplacement.Length) +
 263                                        DoubleQuote;
 264                         return code;
 265                 }
 266
 267                 #region Nested type: ExpressionPosition
 268
 269                 private class ExpressionPosition
 270                 {
 271                         private readonly bool prevCharWasDollarOrBang;
 272                         private readonly bool shouldEscape;
 273                         private readonly int start;
 274                         private int end;
 275
 276                         public ExpressionPosition(int start, int end, bool prevCharWasDollarOrBang, bool shouldEscape)
 277                         {
 278                                 this.start = start;
 279                                 this.end = end;
 280                                 this.prevCharWasDollarOrBang = prevCharWasDollarOrBang;
 281                                 this.shouldEscape = shouldEscape;
 282                         }
 283
 284                         public int Start
 285                         {
 286                                 get { return start; }
 287                         }
 288
 289                         public int End
 290                         {
 291                                 get { return end; }
 292                                 set { end = value; }
 293                         }
 294
 295                         public bool PrevCharWasDollarOrBang
 296                         {
 297                                 get { return prevCharWasDollarOrBang; }
 298                         }
 299
 300                         public bool ShouldEscape
 301                         {
 302                                 get { return shouldEscape; }
 303                         }
 304                 }
 305
 306                 #endregion
 307         }
 308 }