MonoRail/Castle.MonoRail.Views.Brail/Macros/DslMacro.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 namespace Castle.MonoRail.Views.Brail
  16 {
  17     using System;
  18     using System.Collections;
  19     using Boo.Lang.Compiler;
  20     using Boo.Lang.Compiler.Ast;
  21     using Castle.MonoRail.Framework;
  22     using System.Collections.Specialized;
  23     using System.Collections.Generic;
  24     using System.Reflection;
  25
  26     public class DslMacro : AbstractAstMacro
  27     {
  28         readonly IDictionary languages = new HybridDictionary(true);
  29
  30         public DslMacro()
  31         {
  32             languages.Add("html", typeof(HtmlExtension));
  33             languages.Add("xml", typeof(XmlExtension));
  34         }
  35
  36         public override Statement Expand(MacroStatement macro)
  37         {
  38             Block codeBlock = new Block();
  39
  40             // Castle.MonoRail.Views.Brail.DslProvider(BrailBase)
  41             MethodInvocationExpression newDslWrapper = new MethodInvocationExpression();
  42             newDslWrapper.Target = AstUtil.CreateReferenceExpression("Castle.MonoRail.Views.Brail.DslProvider");
  43             newDslWrapper.Arguments.Add(new SelfLiteralExpression());
  44
  45             // dsl = Castle.MonoRail.Views.Brail.DslPRovider(BrailBase)
  46             ReferenceExpression dslReference = AstUtil.CreateReferenceExpression("dsl");
  47             codeBlock.Add(new BinaryExpression(BinaryOperatorType.Assign, dslReference, newDslWrapper));
  48
  49             if (macro.Arguments.Count == 1)
  50             {
  51                 string language = LookupLanguageExtension(macro.Arguments[0].ToString());
  52                 // LanguageExtension(OutputStream)
  53                 MethodInvocationExpression newLanguage = new MethodInvocationExpression();
  54                 newLanguage.Target = AstUtil.CreateReferenceExpression(language);
  55                 newLanguage.Arguments.Add(AstUtil.CreateReferenceExpression("OutputStream"));
  56
  57                 MethodInvocationExpression registerLanguage = new MethodInvocationExpression();
  58                 registerLanguage.Target = AstUtil.CreateReferenceExpression("dsl.Register");
  59                 registerLanguage.Arguments.Add(newLanguage);
  60
  61                 // dsl.Register(LanguageExtension(OutputStream))
  62                 codeBlock.Add(registerLanguage);
  63             }
  64
  65             // rewrite the remaining code to invoke methods on
  66             // the dsl reference
  67             Block macroBlock = macro.Block;
  68             (new NameExpander(dslReference)).Visit(macroBlock);
  69             codeBlock.Add(macroBlock);
  70             // dsl.Flush();
  71             codeBlock.Add(new MethodInvocationExpression(AstUtil.CreateReferenceExpression("dsl.Flush")));
  72             return codeBlock;
  73         }
  74
  75         private string LookupLanguageExtension(string language)
  76         {
  77             if (!languages.Contains(language))
  78             {
  79                 throw new MonoRailException(string.Format("Language '{0}' is not implemented", language));
  80             }
  81
  82             Type languageExtension = (Type)languages[language];
  83             return string.Format("{0}{1}{2}", languageExtension.Namespace, Type.Delimiter, languageExtension.Name);
  84         }
  85
  86         private class NameExpander : DepthFirstTransformer
  87         {
  88             readonly ReferenceExpression _reference = null;
  89             readonly IDictionary<string, Node> _skippedReferences = null;
  90             readonly IDictionary<string, Type> _splitNamespaces = null;
  91
  92             public NameExpander(ReferenceExpression reference)
  93             {
  94                 _reference = reference;
  95                 _skippedReferences = new Dictionary<string, Node>();
  96                 _splitNamespaces = new Dictionary<string, Type>();
  97
  98                 RecordReferenceTypesToSkip(typeof(BrailBase).Assembly);
  99
 100                 foreach (AssemblyName asn in typeof(BrailBase).Assembly.GetReferencedAssemblies())
 101                 {
 102                     RecordReferenceTypesToSkip(Assembly.Load(asn));
 103                 }
 104
 105                 foreach (MethodInfo method in typeof(BrailBase).GetMethods())
 106                 {
 107                     if (!_skippedReferences.ContainsKey(method.Name))
 108                     {
 109                         _skippedReferences.Add(method.Name, new MemberReferenceExpression(new SelfLiteralExpression(), method.Name));
 110                     }
 111                 }
 112             }
 113
 114             private void RecordReferenceTypesToSkip(Assembly asm)
 115             {
 116                 foreach (Type type in asm.GetExportedTypes())
 117                 {
 118                     SplitTypeNameAndRecordReferenceToSkip(type);
 119
 120                     string keyName = string.Format("{0}{1}{2}", type.Namespace, Type.Delimiter, type.Name);
 121
 122                     if (!_skippedReferences.ContainsKey(keyName))
 123                     {
 124                         _skippedReferences.Add(keyName, new ReferenceExpression(keyName));
 125                     }
 126
 127                     if (!_skippedReferences.ContainsKey(type.Name))
 128                     {
 129                         _skippedReferences.Add(type.Name, new ReferenceExpression(type.Name));
 130                     }
 131                 }
 132             }
 133
 134             private void SplitTypeNameAndRecordReferenceToSkip(Type type)
 135             {
 136                 List<string> nsPieces = new List<string>();
 137
 138                 if (!_splitNamespaces.ContainsKey(type.Namespace))
 139                 {
 140                     nsPieces.Clear();
 141
 142                     foreach (string nsPart in type.Namespace.Split(Type.Delimiter))
 143                     {
 144                         nsPieces.Add(nsPart);
 145                         string nsItem = string.Join(new string(Type.Delimiter, 1), nsPieces.ToArray());
 146
 147                         if (!_skippedReferences.ContainsKey(nsPart))
 148                         {
 149                             _skippedReferences.Add(nsPart, new ReferenceExpression(nsPart));
 150                         }
 151
 152                         if (!_skippedReferences.ContainsKey(nsItem))
 153                         {
 154                             _skippedReferences.Add(nsItem, new ReferenceExpression(nsItem));
 155                         }
 156                     }
 157
 158                     _splitNamespaces.Add(type.Namespace, type);
 159                 }
 160             }
 161
 162             public override void OnForStatement(ForStatement node)
 163             {
 164                 base.OnForStatement(node);
 165             }
 166
 167             public override void OnDeclaration(Declaration node)
 168             {
 169                 if (!_skippedReferences.ContainsKey(node.Name))
 170                 {
 171                     _skippedReferences.Add(node.Name, node);
 172                 }
 173
 174                 base.OnDeclaration(node);
 175             }
 176
 177             public override void OnReferenceExpression(ReferenceExpression node)
 178             {
 179                 if (node.ParentNode is BinaryExpression || _skippedReferences.ContainsKey(node.Name))
 180                 {
 181                     base.OnReferenceExpression(node);
 182                     if (!_skippedReferences.ContainsKey(node.Name))
 183                     {
 184                         _skippedReferences.Add(node.Name, node);
 185                     }
 186                     return;
 187                 }
 188
 189                 MemberReferenceExpression mre = new MemberReferenceExpression(node.LexicalInfo);
 190                 mre.Name = node.Name;
 191                 mre.Target = _reference.CloneNode();
 192
 193                 ReplaceCurrentNode(mre);
 194             }
 195         }
 196     }
 197 }