MonoRail/Castle.MonoRail.Framework/Internal/AssemblySourceInfo.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.Framework
  16 {
  17         using System;
  18         using System.Collections;
  19         using System.Collections.Specialized;
  20         using System.IO;
  21         using System.Reflection;
  22
  23         /// <summary>
  24         /// Represents a source of views in an assembly resource.
  25         /// </summary>
  26         public class AssemblySourceInfo
  27         {
  28                 private readonly String assemblyName;
  29                 private readonly String _namespace;
  30                 private readonly IDictionary entries = new HybridDictionary(true);
  31                 private readonly Assembly loadedAssembly;
  32
  33                 /// <summary>
  34                 /// Initializes a new instance of the <see cref="AssemblySourceInfo"/> class.
  35                 /// </summary>
  36                 /// <param name="assemblyName">Name of the assembly.</param>
  37                 /// <param name="_namespace">The _namespace.</param>
  38                 public AssemblySourceInfo(string assemblyName, string _namespace)
  39                 {
  40                         this.assemblyName = assemblyName;
  41                         this._namespace = _namespace;
  42
  43                         loadedAssembly = Assembly.Load(assemblyName);
  44
  45                         RegisterEntries();
  46                 }
  47
  48                 /// <summary>
  49                 /// Gets the name of the assembly.
  50                 /// </summary>
  51                 /// <value>The name of the assembly.</value>
  52                 public string AssemblyName
  53                 {
  54                         get { return assemblyName; }
  55                 }
  56
  57                 /// <summary>
  58                 /// Gets the namespace.
  59                 /// </summary>
  60                 /// <value>The namespace.</value>
  61                 public string Namespace
  62                 {
  63                         get { return _namespace; }
  64                 }
  65
  66                 /// <summary>
  67                 /// Determines whether the assembly has the specified template.
  68                 /// </summary>
  69                 /// <param name="templateName">Name of the template.</param>
  70                 /// <returns>
  71                 ///     <c>true</c> if the specified exists on the assembly; otherwise, <c>false</c>.
  72                 /// </returns>
  73                 public bool HasTemplate(String templateName)
  74                 {
  75                         return entries.Contains(NormalizeTemplateName(templateName));
  76                 }
  77
  78                 /// <summary>
  79                 /// Gets the template stream.
  80                 /// </summary>
  81                 /// <param name="templateName">Name of the template.</param>
  82                 /// <returns></returns>
  83                 public Stream GetTemplateStream(String templateName)
  84                 {
  85                         String resourcePath = (String) entries[NormalizeTemplateName(templateName)];
  86
  87                         return loadedAssembly.GetManifestResourceStream(resourcePath);
  88                 }
  89
  90                 /// <summary>
  91                 /// Collects the views on the assembly resource.
  92                 /// </summary>
  93                 /// <param name="dirName">Name of the dir.</param>
  94                 /// <param name="views">The views.</param>
  95                 public void CollectViews(string dirName, ArrayList views)
  96                 {
  97
  98                         dirName = NormalizeTemplateName(dirName);
  99
 100                         String[] names = loadedAssembly.GetManifestResourceNames();
 101
 102                         for(int i=0; i < names.Length; i++)
 103                         {
 104                                 String name = names[i].ToLower(System.Globalization.CultureInfo.InvariantCulture);
 105
 106                                 name = RemovePrefix(_namespace, name);
 107
 108                                 if (name.StartsWith(dirName.ToLower(System.Globalization.CultureInfo.InvariantCulture)))
 109                                 {
 110                                         views.Add(
 111                                                 Path.Combine(dirName, RemovePrefix(dirName, name))
 112                                                 );
 113                                 }
 114                         }
 115                 }
 116
 117                 private string RemovePrefix(string prefix, string name)
 118                 {
 119                         int toStripLength = prefix.Length;
 120                         if (name.StartsWith(prefix.ToLower(System.Globalization.CultureInfo.InvariantCulture)))
 121                         {
 122                                 if (name[toStripLength] == '.')
 123                                 {
 124                                         return name.Substring(toStripLength + 1);
 125                                 }
 126                                 else
 127                                 {
 128                                         return name.Substring(toStripLength);
 129                                 }
 130                         }
 131                         return name;
 132                 }
 133
 134                 /// <summary>
 135                 /// Normalizes the name of the template.
 136                 /// </summary>
 137                 /// <param name="templateName">Name of the template.</param>
 138                 /// <returns></returns>
 139                 private static String NormalizeTemplateName(string templateName)
 140                 {
 141                         return templateName.Replace('/', '.').Replace('\\', '.');
 142                 }
 143
 144                 /// <summary>
 145                 /// Registers the entries.
 146                 /// </summary>
 147                 private void RegisterEntries()
 148                 {
 149                         int toStripLength = _namespace.Length;
 150
 151                         String[] names = loadedAssembly.GetManifestResourceNames();
 152
 153                         for(int i=0; i < names.Length; i++)
 154                         {
 155                                 String name = names[i].ToLower(System.Globalization.CultureInfo.InvariantCulture);
 156
 157                                 if (name.StartsWith(_namespace.ToLower(System.Globalization.CultureInfo.InvariantCulture)))
 158                                 {
 159                                         if (name[toStripLength] == '.')
 160                                         {
 161                                                 name = name.Substring(toStripLength + 1);
 162                                         }
 163                                         else
 164                                         {
 165                                                 name = name.Substring(toStripLength);
 166                                         }
 167                                 }
 168
 169                                 // Registers the lookup name
 170                                 // associated to the original name
 171                                 entries.Add(name, names[i]);
 172                         }
 173                 }
 174         }
 175 }