MonoRail/Castle.MonoRail.Framework/Views/FileAssemblyViewSourceLoader.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 using System.Text;
  16
  17 namespace Castle.MonoRail.Framework
  18 {
  19         using System;
  20         using System.Collections;
  21         using System.IO;
  22         using Castle.MonoRail.Framework.Configuration;
  23         using Castle.MonoRail.Framework.Views;
  24
  25         /// <summary>
  26         /// Default <see cref="IViewSourceLoader"/> implementation
  27         /// that uses the file system and assembly source as source of view templates
  28         /// </summary>
  29         public class FileAssemblyViewSourceLoader : IViewSourceLoader, IMRServiceEnabled
  30         {
  31                 private readonly IList additionalSources = ArrayList.Synchronized(new ArrayList());
  32                 private bool enableCache = true;
  33                 private string viewRootDir;
  34                 private string virtualViewDir;
  35                 private FileSystemWatcher viewFolderWatcher;
  36
  37                 /// <summary>
  38                 /// Creates a new instance
  39                 /// </summary>
  40                 public FileAssemblyViewSourceLoader()
  41                 {
  42                 }
  43
  44                 ///<summary>
  45                 /// Creates a new instance with the viewRootDir
  46                 ///</summary>
  47                 public FileAssemblyViewSourceLoader(string viewRootDir)
  48                 {
  49                         this.viewRootDir = viewRootDir;
  50                 }
  51
  52                 #region IMRServiceEnabled implementation
  53
  54                 /// <summary>
  55                 /// Services the specified provider.
  56                 /// </summary>
  57                 /// <param name="provider">The provider.</param>
  58                 public void Service(IMonoRailServices provider)
  59                 {
  60                         IMonoRailConfiguration config = (IMonoRailConfiguration) provider.GetService(typeof(IMonoRailConfiguration));
  61
  62                         if (config != null)
  63                         {
  64                                 viewRootDir = config.ViewEngineConfig.ViewPathRoot;
  65                                 virtualViewDir = config.ViewEngineConfig.VirtualPathRoot;
  66
  67                                 foreach(AssemblySourceInfo sourceInfo in config.ViewEngineConfig.Sources)
  68                                 {
  69                                         AddAssemblySource(sourceInfo);
  70                                 }
  71                         }
  72                 }
  73
  74                 #endregion
  75
  76                 /// <summary>
  77                 /// Evaluates whether the specified template exists.
  78                 /// </summary>
  79                 /// <param name="sourceName">The template name</param>
  80                 /// <returns><c>true</c> if it exists</returns>
  81                 public bool HasSource(String sourceName)
  82                 {
  83                         if (HasTemplateOnFileSystem(sourceName))
  84                         {
  85                                 return true;
  86                         }
  87
  88                         return HasTemplateOnAssemblies(sourceName);
  89                 }
  90
  91                 /// <summary>
  92                 /// Builds and returns a representation of a view template
  93                 /// </summary>
  94                 /// <param name="templateName">The template name</param>
  95                 /// <returns></returns>
  96                 public IViewSource GetViewSource(String templateName)
  97                 {
  98                         FileInfo fileInfo = CreateFileInfo(templateName);
  99
 100                         if (fileInfo.Exists)
 101                         {
 102                                 return new FileViewSource(fileInfo, enableCache);
 103                         }
 104                         else
 105                         {
 106                                 return GetStreamFromAdditionalSources(templateName);
 107                         }
 108                 }
 109
 110         /// <summary>
 111         /// Gets a list of views on the specified directory
 112         /// </summary>
 113         /// <param name="dirName">Directory name</param>
 114         /// <param name="fileExtensionsToInclude">Optional fileExtensions to include in listing.</param>
 115         /// <returns></returns>
 116                 public String[] ListViews(String dirName,params string[] fileExtensionsToInclude)
 117                 {
 118                         ArrayList views = new ArrayList();
 119
 120                         CollectViewsOnFileSystem(dirName, views,fileExtensionsToInclude);
 121                         CollectViewsOnAssemblies(dirName, views);
 122
 123                         return (String[]) views.ToArray(typeof(String));
 124                 }
 125
 126                 /// <summary>
 127                 /// Gets/sets the root directory of views, obtained from the configuration.
 128                 /// </summary>
 129                 /// <value></value>
 130                 public string VirtualViewDir
 131                 {
 132                         get { return virtualViewDir; }
 133                         set { virtualViewDir = value; }
 134                 }
 135
 136                 /// <summary>
 137                 /// Gets/sets the root directory of views,
 138                 /// obtained from the configuration.
 139                 /// </summary>
 140                 public string ViewRootDir
 141                 {
 142                         get { return viewRootDir; }
 143                         set { viewRootDir = value; }
 144                 }
 145
 146                 /// <summary>
 147                 /// Gets or sets whether the instance should use cache
 148                 /// </summary>
 149                 /// <value></value>
 150                 public bool EnableCache
 151                 {
 152                         get { return enableCache; }
 153                         set { enableCache = value; }
 154                 }
 155
 156                 /// <summary>
 157                 /// Gets a list of assembly sources
 158                 /// </summary>
 159                 /// <value></value>
 160                 public IList AssemblySources
 161                 {
 162                         get { return additionalSources; }
 163                 }
 164
 165                 /// <summary>
 166                 /// Adds the assembly source.
 167                 /// </summary>
 168                 /// <param name="assemblySourceInfo">The assembly source info.</param>
 169                 public void AddAssemblySource(AssemblySourceInfo assemblySourceInfo)
 170                 {
 171                         additionalSources.Add(assemblySourceInfo);
 172                 }
 173
 174                 #region Handle File System Changes To Views
 175
 176                 /// <summary>
 177                 /// Raised when the view is changed.
 178                 /// </summary>
 179                 public event FileSystemEventHandler ViewChanged
 180                 {
 181                         add
 182                         {
 183                                 //avoid concurrency problems with creating/removing the watcher
 184                                 //in two threads in parallel. Unlikely, but better to be safe.
 185                                 lock(this)
 186                                 {
 187                                         //create the watcher if it doesn't exists
 188                                         if (viewFolderWatcher == null)
 189                                         {
 190                                                 InitViewFolderWatch();
 191                                         }
 192                                         ViewChangedImpl += value;
 193                                 }
 194                         }
 195                         remove
 196                         {
 197                                 //avoid concurrency problems with creating/removing the watcher
 198                                 //in two threads in parallel. Unlikely, but better to be safe.
 199                                 lock(this)
 200                                 {
 201                                         ViewChangedImpl -= value;
 202                                         if (ViewChangedImpl == null) //no more subscribers.
 203                                         {
 204                                                 DisposeViewFolderWatch();
 205                                         }
 206                                 }
 207                         }
 208                 }
 209
 210                 private event FileSystemEventHandler ViewChangedImpl = delegate { };
 211
 212                 private void DisposeViewFolderWatch()
 213                 {
 214                         ViewChangedImpl -= (viewFolderWatcher_Changed);
 215                         if (viewFolderWatcher != null)
 216                         {
 217                                 viewFolderWatcher.Dispose();
 218                         }
 219                 }
 220
 221                 private void InitViewFolderWatch()
 222                 {
 223                         if (Directory.Exists(ViewRootDir))
 224                         {
 225                                 viewFolderWatcher = new FileSystemWatcher(ViewRootDir);
 226                                 viewFolderWatcher.IncludeSubdirectories = true;
 227                                 viewFolderWatcher.Changed += (viewFolderWatcher_Changed);
 228                                 viewFolderWatcher.Created += (viewFolderWatcher_Changed);
 229                                 viewFolderWatcher.Deleted += (viewFolderWatcher_Changed);
 230                                 viewFolderWatcher.Renamed += (viewFolderWatcher_Renamed);
 231                                 viewFolderWatcher.EnableRaisingEvents = true;
 232                         }
 233                 }
 234
 235                 private void viewFolderWatcher_Renamed(object sender, RenamedEventArgs e)
 236                 {
 237                         ViewChangedImpl(this, e);
 238                 }
 239
 240                 private void viewFolderWatcher_Changed(object sender, FileSystemEventArgs e)
 241                 {
 242                         ViewChangedImpl(this, e);
 243                 }
 244
 245                 #endregion
 246
 247                 private bool HasTemplateOnFileSystem(string templateName)
 248                 {
 249                         return CreateFileInfo(templateName).Exists;
 250                 }
 251
 252                 private FileInfo CreateFileInfo(string templateName)
 253                 {
 254                         if (Path.IsPathRooted(templateName))
 255                         {
 256                                 templateName = templateName.Substring(Path.GetPathRoot(templateName).Length);
 257                         }
 258
 259                         return new FileInfo(Path.Combine(viewRootDir, templateName));
 260                 }
 261
 262                 private bool HasTemplateOnAssemblies(string templateName)
 263                 {
 264                         foreach(AssemblySourceInfo sourceInfo in additionalSources)
 265                         {
 266                                 if (sourceInfo.HasTemplate(templateName))
 267                                 {
 268                                         return true;
 269                                 }
 270                         }
 271
 272                         return false;
 273                 }
 274
 275                 private IViewSource GetStreamFromAdditionalSources(string templateName)
 276                 {
 277                         foreach(AssemblySourceInfo sourceInfo in additionalSources)
 278                         {
 279                                 if (sourceInfo.HasTemplate(templateName))
 280                                 {
 281                                         return new EmbeddedResourceViewSource(templateName, sourceInfo);
 282                                 }
 283                         }
 284
 285                         return null;
 286                 }
 287
 288                 private void CollectViewsOnFileSystem(string dirName, ArrayList views,params string[] fileExtensionsToInclude)
 289                 {
 290                         DirectoryInfo dir = new DirectoryInfo(Path.Combine(ViewRootDir, dirName));
 291             if(!dir.Exists)
 292             {
 293                 return; //early return
 294             }
 295
 296
 297             if(fileExtensionsToInclude ==null || fileExtensionsToInclude.Length==0)
 298             {
 299                 fileExtensionsToInclude = new string[] {".*"};
 300             }
 301
 302                     foreach (string ext in fileExtensionsToInclude)
 303                     {
 304                 foreach (FileInfo file in dir.GetFiles("*" + ext))
 305                 {
 306                     views.Add(Path.Combine(dirName, file.Name));
 307                 }
 308                     }
 309
 310                 }
 311
 312                 private void CollectViewsOnAssemblies(string dirName, ArrayList views)
 313                 {
 314                         foreach(AssemblySourceInfo sourceInfo in additionalSources)
 315                         {
 316                                 sourceInfo.CollectViews(dirName, views);
 317                         }
 318                 }
 319         }
 320 }