Add support for Virtual Paths as part of the application structure

Source/Rejuicer/Rejuicer/Engine/FileResolver.cs

@@ -19,7 +19,7 @@ static FileResolver()
 
         public static IEnumerable<string> VirtualPathsFor(RejuicerConfigurationSource config)
         {
-            return config == null ? Enumerable.Empty<string>() : config.GetDependencies(config.ResourceType).Select(f => VirtualPathResolver.GetVirtualPathFor(f));
+            return config == null ? Enumerable.Empty<string>() : config.GetFiles(config.ResourceType);
         }
 
         private class FileComparer : IEqualityComparer<FileInfo>

Source/Rejuicer/Rejuicer/Engine/PhysicalFileRegister.cs

@@ -27,16 +27,16 @@ public static PhysicalFileSource For(string virtualPath)
             return fileSourceRegister.ContainsKey(virtualPath) ? fileSourceRegister[virtualPath] : null;
         }
 
-        public static PhysicalFileSource For(FileInfo file, ResourceType resourceType, Mode mode)
+        public static PhysicalFileSource For(string virtualPath, ResourceType resourceType, Mode mode)
         {
-            var virtualPathFor = VirtualPathResolver.GetVirtualPathFor(file);
+            var file = new FileInfo(VirtualPathResolver.ResolveVirtualPath(virtualPath));
 
-            var physicalFileSource = For(virtualPathFor);
+            var physicalFileSource = For(virtualPath);
 
             if (physicalFileSource == null)
             {
-                physicalFileSource = new PhysicalFileSource(resourceType, 
-                                                            virtualPathFor,
+                physicalFileSource = new PhysicalFileSource(resourceType,
+                                                            virtualPath,
                                                             file.FullName,
                                                             mode);
 

Source/Rejuicer/Rejuicer/Model/IContentSource.cs

@@ -12,6 +12,8 @@ public interface IContentSource
         ResourceType ResourceType { get; }
         IEnumerable<FileInfo> GetDependencies(ResourceType? resourceType);
         IEnumerable<FileInfo> GetDependencies();
+        IEnumerable<string> GetFiles(ResourceType? resourceType);
+        IEnumerable<string> GetFiles();
         OutputContent GetContent(ICacheProvider cacheProvider);
     }
 }

Source/Rejuicer/Rejuicer/Model/PhysicalFileSource.cs

@@ -51,6 +51,31 @@ public IEnumerable<FileInfo> GetDependencies(ResourceType? resourceType)
             }
         }
 
+        public IEnumerable<string> GetFiles()
+        {
+            return GetFiles(null);
+        }
+
+        public IEnumerable<string> GetFiles(ResourceType? resourceType)
+        {
+            _lock.EnterReadLock();
+            try
+            {
+                var dependencies = _dependencies.SelectMany(x => x.GetFiles(resourceType));
+
+                if (!resourceType.HasValue || ResourceType == resourceType.Value)
+                {
+                    dependencies = dependencies.Union(new[] { VirtualPath });
+                }
+
+                return dependencies;
+            }
+            finally
+            {
+                _lock.ExitReadLock();
+            }
+        }
+
         public OutputContent GetContent(ICacheProvider cacheProvider)
         {
             return GetContent(cacheProvider, Mode);

Source/Rejuicer/Rejuicer/Model/RejuicerConfigurationSource.cs

@@ -98,6 +98,24 @@ public IEnumerable<FileInfo> GetDependencies(ResourceType? resourceType)
             }
         }
 
+        public IEnumerable<string> GetFiles()
+        {
+            return GetFiles(null);
+        }
+
+        public IEnumerable<string> GetFiles(ResourceType? resourceType)
+        {
+            _lock.EnterReadLock();
+            try
+            {
+                return this.SelectMany(x => x.GetFiles(resourceType)).Distinct();
+            }
+            finally
+            {
+                _lock.ExitReadLock();
+            }
+        }
+
         public DateTime GetLastModifiedDate(ICacheProvider cacheProvider)
         {
             return GetContent(cacheProvider).LastModifiedDate;

Source/Rejuicer/Rejuicer/Rules/SingleFileRule.cs

@@ -42,7 +42,7 @@ public IOrderedEnumerable<IContentSource> Evaluate(ResourceType resourceType)
                 return Enumerable.Empty<IContentSource>().OrderBy(x => x);
             }
 
-            return new IContentSource[] { PhysicalFileRegister.For(file, resourceType, Mode) }.OrderBy(x => x);
+            return new IContentSource[] { PhysicalFileRegister.For(VirtualPath, resourceType, Mode) }.OrderBy(x => x);
         }
     }
 }

Source/Rejuicer/Rejuicer/Rules/WildcardMatchFileRule.cs

@@ -51,10 +51,10 @@ public IOrderedEnumerable<IContentSource> Evaluate(ResourceType resourceType)
             if (physicalPath == null)
                 return Enumerable.Empty<IContentSource>().OrderBy(x => x);
 
-            return Directory.GetFiles(physicalPath.FullName, SearchPattern ?? "*", IsRecursive ? SearchOption.AllDirectories : SearchOption.TopDirectoryOnly)
+            return Directory.EnumerateFiles(physicalPath.FullName, SearchPattern ?? "*", IsRecursive ? SearchOption.AllDirectories : SearchOption.TopDirectoryOnly)
                         .Select(f => new FileInfo(f))
                         .Where(FileNotExcluded)
-                        .Select(file => PhysicalFileRegister.For(file, resourceType, Mode))
+                        .Select(file => PhysicalFileRegister.For(string.Format("{0}/{1}", FolderVirtualPath, file.Name), resourceType, Mode))
                         .OfType<IContentSource>()
                         .OrderBy(x => new FileInfo(((PhysicalFileSource)x).PhysicalPath).Name);
         }