- Refactoring IPackageManager: we want an IExtensionManager because extensions like packages and themes share a lot of aspects.

--HG-- extra : convert_revision : svn%3A5ff7c347-ad56-4c35-b696-ccb81de16e03/trunk%4043646
2025-09-23 04:43:35 +08:00 · 2009-12-10 01:32:26 +00:00
parent 85f8b1d03b
commit 73a1740817
28 changed files with 178 additions and 222 deletions
--- a/src/Orchard.Tests/Environment/DefaultCompositionStrategyTests.cs
+++ b/src/Orchard.Tests/Environment/DefaultCompositionStrategyTests.cs
@@ -1,10 +1,7 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
+using System.Linq;
 using NUnit.Framework;
 using Orchard.Environment;
-using Orchard.Packages;
+using Orchard.Extensions;
 using Orchard.Tests.Models.Records;
 using Orchard.Tests.Models.Stubs;

@@ -13,12 +10,12 @@ namespace Orchard.Tests.Environment {
    public class DefaultCompositionStrategyTests {
        [Test]
        public void ExpectedRecordsShouldComeBack() {
-            var packageManager = new Moq.Mock<IPackageManager>();
-            packageManager.Setup(x => x.ActivePackages()).Returns(new[] {
-                                                                            new PackageEntry
+            var extensionManager = new Moq.Mock<IExtensionManager>();
+            extensionManager.Setup(x => x.ActiveExtensions()).Returns(new[] {
+                                                                            new ExtensionEntry
                                                                            {ExportedTypes = new[] {typeof (GammaRecord), typeof (DeltaRecord), typeof (Delta)}}
                                                                        });
-            var strategy = new DefaultCompositionStrategy(packageManager.Object);
+            var strategy = new DefaultCompositionStrategy(extensionManager.Object);
            var recordTypes = strategy.GetRecordTypes();

            Assert.That(recordTypes.Count(), Is.Not.EqualTo(0));
--- a/src/Orchard.Tests/Environment/DefaultOrchardHostTests.cs
+++ b/src/Orchard.Tests/Environment/DefaultOrchardHostTests.cs
@@ -2,12 +2,9 @@
 using System.Collections.Generic;
 using System.Linq;
 using System.Reflection;
-using System.Text;
-using System.Web;
 using System.Web.Mvc;
 using System.Web.Routing;
 using Autofac;
-using Autofac.Builder;
 using Autofac.Integration.Web;
 using Autofac.Modules;
 using NUnit.Framework;
@@ -15,9 +12,8 @@ using Orchard.Environment;
 using Orchard.Mvc;
 using Orchard.Mvc.ModelBinders;
 using Orchard.Mvc.Routes;
-using Orchard.Packages;
+using Orchard.Extensions;
 using Orchard.Tests.Environment.TestDependencies;
-using Orchard.Tests.Mvc.Routes;
 using Orchard.Tests.Stubs;

 namespace Orchard.Tests.Environment {
@@ -46,17 +42,17 @@ namespace Orchard.Tests.Environment {
                    builder.Register(_routeCollection);
                    builder.Register(_modelBinderDictionary);
                    builder.Register(new ViewEngineCollection { new WebFormViewEngine() });
-                    builder.Register(new StuPackageManager()).As<IPackageManager>();
+                    builder.Register(new StuExtensionManager()).As<IExtensionManager>();
                });
        }

-        public class StuPackageManager : IPackageManager {
-            public IEnumerable<PackageDescriptor> AvailablePackages() {
-                return Enumerable.Empty<PackageDescriptor>();
+        public class StuExtensionManager : IExtensionManager {
+            public IEnumerable<ExtensionDescriptor> AvailableExtensions() {
+                return Enumerable.Empty<ExtensionDescriptor>();
            }

-            public IEnumerable<PackageEntry> ActivePackages() {
-                return Enumerable.Empty<PackageEntry>();
+            public IEnumerable<ExtensionEntry> ActiveExtensions() {
+                return Enumerable.Empty<ExtensionEntry>();
            }
        }

--- a/src/Orchard.Tests/Environment/DefaultOrchardShellTests.cs
+++ b/src/Orchard.Tests/Environment/DefaultOrchardShellTests.cs
@@ -1,14 +1,13 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
-using System.Text;
 using System.Web.Mvc;
 using System.Web.Routing;
 using NUnit.Framework;
 using Orchard.Environment;
 using Orchard.Mvc.ModelBinders;
 using Orchard.Mvc.Routes;
-using Orchard.Packages;
+using Orchard.Extensions;

 namespace Orchard.Tests.Environment {
    [TestFixture]
@@ -38,7 +37,7 @@ namespace Orchard.Tests.Environment {
                new[] { modelBinderProvider1, modelBinderProvider2 },
                modelBinderPublisher,
                new ViewEngineCollection { new WebFormViewEngine() },
-                new Moq.Mock<IPackageManager>().Object,
+                new Moq.Mock<IExtensionManager>().Object,
                Enumerable.Empty<IOrchardShellEvents>());

            runtime.Activate();
--- a/src/Orchard.Tests/Extensions/ExtensionFoldersTests.cs
+++ b/src/Orchard.Tests/Extensions/ExtensionFoldersTests.cs
@@ -1,16 +1,13 @@
-using System;
-using System.Collections.Generic;
-using System.IO;
+using System.IO;
 using System.Linq;
-using System.Text;
 using NUnit.Framework;
-using Orchard.Packages;
+using Orchard.Extensions;
 using Yaml.Grammar;

-namespace Orchard.Tests.Packages {
+namespace Orchard.Tests.Extensions {
    [TestFixture]
-    public class PackageFoldersTests {
-        private const string DataPrefix = "Orchard.Tests.Packages.FoldersData.";
+    public class ExtensionFoldersTests {
+        private const string DataPrefix = "Orchard.Tests.Extensions.FoldersData.";
        private string _tempFolderName;

        [SetUp]
@@ -52,7 +49,7 @@ namespace Orchard.Tests.Packages {

        [Test]
        public void NamesFromFoldersWithPackageTxtShouldBeListed() {
-            var folders = new PackageFolders(new[] { _tempFolderName });
+            var folders = new ExtensionFolders(new[] { _tempFolderName });
            var names = folders.ListNames();
            Assert.That(names.Count(), Is.EqualTo(2));
            Assert.That(names, Has.Some.EqualTo("Sample1"));
@@ -61,11 +58,11 @@ namespace Orchard.Tests.Packages {

        [Test]
        public void PackageTxtShouldBeParsedAndReturnedAsYamlDocument() {
-            var folders = new PackageFolders(new[] { _tempFolderName });
+            var folders = new ExtensionFolders(new[] { _tempFolderName });
            var sample1 = folders.ParseManifest("Sample1");
            var mapping = (Mapping)sample1.YamlDocument.Root;
            var entities = mapping.Entities
-                .Where(x=>x.Key is Scalar)
+                .Where(x => x.Key is Scalar)
                .ToDictionary(x => ((Scalar)x.Key).Text, x => x.Value);
            Assert.That(entities.Keys, Has.Some.EqualTo("name"));
            Assert.That(entities.Keys, Has.Some.EqualTo("author"));
--- a/src/Orchard.Tests/Extensions/ExtensionManagerTests.cs
+++ b/src/Orchard.Tests/Extensions/ExtensionManagerTests.cs
@@ -1,21 +1,17 @@
-using System;
-using System.Collections;
-using System.Collections.Generic;
+using System.Collections.Generic;
 using System.Linq;
-using System.Text;
 using Autofac;
 using Autofac.Builder;
 using Autofac.Modules;
 using NUnit.Framework;
-using Orchard.Packages;
-using Orchard.Packages.Loaders;
+using Orchard.Extensions;
 using Yaml.Grammar;

-namespace Orchard.Tests.Packages {
+namespace Orchard.Tests.Extensions {
    [TestFixture]
-    public class PackageManagerTests {
+    public class ExtensionManagerTests {
        private IContainer _container;
-        private IPackageManager _manager;
+        private IExtensionManager _manager;
        private StubFolders _folders;

        [SetUp]
@@ -23,13 +19,13 @@ namespace Orchard.Tests.Packages {
            var builder = new ContainerBuilder();
            _folders = new StubFolders();
            builder.RegisterModule(new ImplicitCollectionSupportModule());
-            builder.Register(_folders).As<IPackageFolders>();
-            builder.Register<PackageManager>().As<IPackageManager>();
+            builder.Register(_folders).As<IExtensionFolders>();
+            builder.Register<ExtensionManager>().As<IExtensionManager>();
            _container = builder.Build();
-            _manager = _container.Resolve<IPackageManager>();
+            _manager = _container.Resolve<IExtensionManager>();
        }

-        public class StubFolders : IPackageFolders {
+        public class StubFolders : IExtensionFolders {
            public StubFolders() {
                Manifests = new Dictionary<string, string>();
            }
@@ -57,30 +53,30 @@ namespace Orchard.Tests.Packages {


        [Test]
-        public void AvailablePackagesShouldFollowCatalogLocations() {
+        public void AvailableExtensionsShouldFollowCatalogLocations() {
            _folders.Manifests.Add("foo", "name: Foo");
            _folders.Manifests.Add("bar", "name: Bar");
            _folders.Manifests.Add("frap", "name: Frap");
            _folders.Manifests.Add("quad", "name: Quad");

-            var available = _manager.AvailablePackages();
+            var available = _manager.AvailableExtensions();

            Assert.That(available.Count(), Is.EqualTo(4));
            Assert.That(available, Has.Some.Property("Name").EqualTo("foo"));
        }

        [Test]
-        public void PackageDescriptorsShouldHaveNameAndDescription() {
+        public void ExtensionDescriptorsShouldHaveNameAndDescription() {

            _folders.Manifests.Add("Sample", @"
-name: Sample Package
+name: Sample Extension
 description: This is the description
 version: 2.x
 ");

-            var descriptor = _manager.AvailablePackages().Single();
+            var descriptor = _manager.AvailableExtensions().Single();
            Assert.That(descriptor.Name, Is.EqualTo("Sample"));
-            Assert.That(descriptor.DisplayName, Is.EqualTo("Sample Package"));
+            Assert.That(descriptor.DisplayName, Is.EqualTo("Sample Extension"));
            Assert.That(descriptor.Description, Is.EqualTo("This is the description"));
            Assert.That(descriptor.Version, Is.EqualTo("2.x"));
        }
--- a/src/Orchard.Tests/Extensions/FoldersData/Sample1/Package.txt
+++ b/src/Orchard.Tests/Extensions/FoldersData/Sample1/Package.txt
--- a/src/Orchard.Tests/Extensions/FoldersData/Sample2/Two.txt
+++ b/src/Orchard.Tests/Extensions/FoldersData/Sample2/Two.txt
--- a/src/Orchard.Tests/Extensions/FoldersData/Sample3/Package.txt
+++ b/src/Orchard.Tests/Extensions/FoldersData/Sample3/Package.txt
--- a/src/Orchard.Tests/Mvc/OrchardControllerIdentificationStrategyTests.cs
+++ b/src/Orchard.Tests/Mvc/OrchardControllerIdentificationStrategyTests.cs
@@ -1,18 +1,15 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
+using System.Linq;
 using System.Web.Mvc;
 using Autofac;
 using NUnit.Framework;
 using Orchard.Mvc;
-using Orchard.Packages;
+using Orchard.Extensions;

 namespace Orchard.Tests.Mvc {
   [TestFixture] public class OrchardControllerIdentificationStrategyTests {
       [Test]
       public void IdentificationStrategyAddsAssemblyNameAsAreaPrefixToControllerNames() {
-           var strategy = new OrchardControllerIdentificationStrategy(Enumerable.Empty<PackageEntry>());
+           var strategy = new OrchardControllerIdentificationStrategy(Enumerable.Empty<ExtensionEntry>());
           var service = strategy.ServiceForControllerType(typeof (StrategyTestingController));
           Assert.That(service, Is.TypeOf<NamedService>());
           Assert.That(((NamedService)service).ServiceName, Is.EqualTo("controller.orchard.tests.strategytesting"));
--- a/src/Orchard.Tests/Mvc/Routes/StandardExtensionRouteProviderTests.cs
+++ b/src/Orchard.Tests/Mvc/Routes/StandardExtensionRouteProviderTests.cs
@@ -1,19 +1,18 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
-using System.Text;
 using System.Web.Routing;
 using NUnit.Framework;
 using Orchard.Mvc.Routes;
-using Orchard.Packages;
+using Orchard.Extensions;

 namespace Orchard.Tests.Mvc.Routes {
    [TestFixture]
-    public class StandardPackageRouteProviderTests {
+    public class StandardExtensionRouteProviderTests {
        [Test]
-        public void PackageDisplayNameShouldBeUsedInBothStandardRoutes() {
-            var stubManager = new StubPackageManager();
-            var routeProvider = new StandardPackageRouteProvider(stubManager);
+        public void ExtensionDisplayNameShouldBeUsedInBothStandardRoutes() {
+            var stubManager = new StubExtensionManager();
+            var routeProvider = new StandardExtensionRouteProvider(stubManager);

            var routes = new List<RouteDescriptor>();
            routeProvider.GetRoutes(routes);
@@ -34,20 +33,20 @@ namespace Orchard.Tests.Mvc.Routes {
            Assert.That(barRoute.DataTokens["area"], Is.EqualTo("Long.Name.Bar"));
        }

-        public class StubPackageManager : IPackageManager {
-            public IEnumerable<PackageDescriptor> AvailablePackages() {
+        public class StubExtensionManager : IExtensionManager {
+            public IEnumerable<ExtensionDescriptor> AvailableExtensions() {
                throw new NotImplementedException();
            }

-            public IEnumerable<PackageEntry> ActivePackages() {
-                yield return new PackageEntry {
-                    Descriptor = new PackageDescriptor {
+            public IEnumerable<ExtensionEntry> ActiveExtensions() {
+                yield return new ExtensionEntry {
+                    Descriptor = new ExtensionDescriptor {
                        Name = "Long.Name.Foo",
                        DisplayName = "Foo",
                    }
                };
-                yield return new PackageEntry {
-                    Descriptor = new PackageDescriptor {
+                yield return new ExtensionEntry {
+                    Descriptor = new ExtensionDescriptor {
                        Name = "Long.Name.Bar",
                        DisplayName = "Bar",
                    }
--- a/src/Orchard.Tests/Orchard.Tests.csproj
+++ b/src/Orchard.Tests/Orchard.Tests.csproj
@@ -43,6 +43,8 @@
      <SpecificVersion>False</SpecificVersion>
      <HintPath>..\..\lib\fluentnhibernate\FluentNHibernate.dll</HintPath>
    </Reference>
+    <Reference Include="Microsoft.VisualStudio.QualityTools.UnitTestFramework, Version=9.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a" />
+    <Reference Include="Microsoft.VisualStudio.TeamSystem.Data.UnitTesting, Version=9.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a" />
    <Reference Include="Moq, Version=4.0.812.4, Culture=neutral, PublicKeyToken=69f491c39445e920, processorArchitecture=MSIL">
      <SpecificVersion>False</SpecificVersion>
      <HintPath>..\..\lib\moq\Moq.dll</HintPath>
@@ -64,6 +66,7 @@
      <HintPath>..\..\lib\nunit\nunit.framework.dll</HintPath>
    </Reference>
    <Reference Include="System" />
+    <Reference Include="System.Configuration" />
    <Reference Include="System.Core">
      <RequiredTargetFramework>3.5</RequiredTargetFramework>
    </Reference>
@@ -106,6 +109,8 @@
    <Compile Include="Environment\OrchardStarterTests.cs" />
    <Compile Include="Environment\TestDependencies\TestDependency.cs" />
    <Compile Include="EventsTests.cs" />
+    <Compile Include="Extensions\ExtensionFoldersTests.cs" />
+    <Compile Include="Extensions\ExtensionManagerTests.cs" />
    <Compile Include="Localization\NullLocalizerTests.cs" />
    <Compile Include="Logging\LoggingModuleTests.cs" />
    <Compile Include="Models\ContentQueryTests.cs" />
@@ -128,12 +133,10 @@
    <Compile Include="Mvc\OrchardControllerFactoryTests.cs" />
    <Compile Include="Mvc\OrchardControllerIdentificationStrategyTests.cs" />
    <Compile Include="Mvc\RouteCollectionPublisherTests.cs" />
-    <Compile Include="Mvc\Routes\StandardPackageRouteProviderTests.cs" />
+    <Compile Include="Mvc\Routes\StandardExtensionRouteProviderTests.cs" />
    <Compile Include="Tasks\SweepGeneratorTests.cs" />
    <Compile Include="UI\Notify\NotifierTests.cs" />
    <Compile Include="UI\Notify\NotifyFilterTests.cs" />
-    <Compile Include="Packages\PackageFoldersTests.cs" />
-    <Compile Include="Packages\PackageManagerTests.cs" />
    <Compile Include="Services\ClockTests.cs" />
    <Compile Include="Storage\FileSystemStorageProviderTests.cs" />
    <Compile Include="Stubs\StubClock.cs" />
@@ -161,11 +164,9 @@
    <None Include="App.config" />
  </ItemGroup>
  <ItemGroup>
-    <EmbeddedResource Include="Packages\FoldersData\Sample2\Two.txt" />
-    <EmbeddedResource Include="Packages\FoldersData\Sample1\Package.txt" />
-  </ItemGroup>
-  <ItemGroup>
-    <EmbeddedResource Include="Packages\FoldersData\Sample3\Package.txt" />
+    <Content Include="Extensions\FoldersData\Sample1\Package.txt" />
+    <Content Include="Extensions\FoldersData\Sample2\Two.txt" />
+    <Content Include="Extensions\FoldersData\Sample3\Package.txt" />
  </ItemGroup>
  <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
  <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
--- a/src/Orchard/Environment/DefaultCompositionStrategy.cs
+++ b/src/Orchard/Environment/DefaultCompositionStrategy.cs
@@ -5,7 +5,7 @@ using System.Reflection;
 using Autofac;
 using Orchard.Models;
 using Orchard.Models.Records;
-using Orchard.Packages;
+using Orchard.Extensions;

 namespace Orchard.Environment {
    //TEMP: This will be replaced by packaging system
@@ -18,21 +18,21 @@ namespace Orchard.Environment {
    }

    public class DefaultCompositionStrategy : ICompositionStrategy {
-        private readonly IPackageManager _packageManager;
+        private readonly IExtensionManager _extensionManager;

-        public DefaultCompositionStrategy(IPackageManager packageManager) {
-            _packageManager = packageManager;
+        public DefaultCompositionStrategy(IExtensionManager extensionManager) {
+            _extensionManager = extensionManager;
        }

        public IEnumerable<Assembly> GetAssemblies() {
-            return _packageManager.ActivePackages()
+            return _extensionManager.ActiveExtensions()
                .Select(entry => entry.Assembly)
                .Concat(new[] { typeof(IOrchardHost).Assembly });
            //return BuildManager.GetReferencedAssemblies().OfType<Assembly>();
        }

        public IEnumerable<Type> GetModuleTypes() {
-            var types = _packageManager.ActivePackages().SelectMany(x => x.ExportedTypes);
+            var types = _extensionManager.ActiveExtensions().SelectMany(x => x.ExportedTypes);
            types = types.Concat(typeof(IOrchardHost).Assembly.GetExportedTypes());
            var nonAbstractClasses = types.Where(t => t.IsClass && !t.IsAbstract);
            var modules = nonAbstractClasses.Where(t => typeof(IModule).IsAssignableFrom(t));
@@ -40,7 +40,7 @@ namespace Orchard.Environment {
        }

        public IEnumerable<Type> GetDependencyTypes() {
-            var types = _packageManager.ActivePackages().SelectMany(x => x.ExportedTypes);
+            var types = _extensionManager.ActiveExtensions().SelectMany(x => x.ExportedTypes);
            types = types.Concat(typeof(IOrchardHost).Assembly.GetExportedTypes());
            var nonAbstractClasses = types.Where(t => t.IsClass && !t.IsAbstract);
            var modules = nonAbstractClasses.Where(t => typeof(IDependency).IsAssignableFrom(t));
@@ -48,7 +48,7 @@ namespace Orchard.Environment {
        }

        public IEnumerable<Type> GetRecordTypes() {
-            var types = _packageManager.ActivePackages().SelectMany(x => x.ExportedTypes);
+            var types = _extensionManager.ActiveExtensions().SelectMany(x => x.ExportedTypes);
            var recordTypes = types.Where(IsRecordType)
                .Concat(new[] { typeof(ContentItemRecord), typeof(ContentPartRecord), typeof(ContentTypeRecord) });
            return recordTypes;
--- a/src/Orchard/Environment/DefaultOrchardShell.cs
+++ b/src/Orchard/Environment/DefaultOrchardShell.cs
@@ -5,7 +5,7 @@ using System.Web.Mvc;
 using Orchard.Logging;
 using Orchard.Mvc.ModelBinders;
 using Orchard.Mvc.Routes;
-using Orchard.Packages;
+using Orchard.Extensions;

 namespace Orchard.Environment {
    public class DefaultOrchardShell : IOrchardShell {
@@ -14,7 +14,7 @@ namespace Orchard.Environment {
        private readonly IEnumerable<IModelBinderProvider> _modelBinderProviders;
        private readonly IModelBinderPublisher _modelBinderPublisher;
        private readonly ViewEngineCollection _viewEngines;
-        private readonly IPackageManager _packageManager;
+        private readonly IExtensionManager _extensionManager;
        private readonly IEnumerable<IOrchardShellEvents> _events;

        public DefaultOrchardShell(
@@ -23,14 +23,14 @@ namespace Orchard.Environment {
            IEnumerable<IModelBinderProvider> modelBinderProviders,
            IModelBinderPublisher modelBinderPublisher,
            ViewEngineCollection viewEngines,
-            IPackageManager packageManager,
+            IExtensionManager extensionManager,
            IEnumerable<IOrchardShellEvents> events) {
            _routeProviders = routeProviders;
            _routePublisher = routePublisher;
            _modelBinderProviders = modelBinderProviders;
            _modelBinderPublisher = modelBinderPublisher;
            _viewEngines = viewEngines;
-            _packageManager = packageManager;
+            _extensionManager = extensionManager;
            _events = events;

            Logger = NullLogger.Instance;
@@ -67,7 +67,7 @@ namespace Orchard.Environment {
                .Distinct()
                .ToArray();

-            var activePackageDescriptors = _packageManager.ActivePackages().Select(x => x.Descriptor);
+            var activePackageDescriptors = _extensionManager.ActiveExtensions().Select(x => x.Descriptor);
            var sharedLocationFormats = activePackageDescriptors.Select(x => ModelsLocationFormat(x));
            viewEngine.PartialViewLocationFormats = sharedLocationFormats
                .Concat(viewEngine.PartialViewLocationFormats)
@@ -83,7 +83,7 @@ namespace Orchard.Environment {
        }


-        private static string ModelsLocationFormat(PackageDescriptor descriptor) {
+        private static string ModelsLocationFormat(ExtensionDescriptor descriptor) {
            return Path.Combine(Path.Combine(descriptor.Location, descriptor.Name), "Views/Models/{0}.ascx");
        }
    }
--- a/src/Orchard/Environment/OrchardStarter.cs
+++ b/src/Orchard/Environment/OrchardStarter.cs
@@ -1,13 +1,10 @@
 using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Web.Hosting;
 using Autofac;
 using Autofac.Builder;
 using Autofac.Integration.Web;
 using Autofac.Modules;
-using Orchard.Packages;
-using Orchard.Packages.Loaders;
+using Orchard.Extensions;
+using Orchard.Extensions.Loaders;

 namespace Orchard.Environment {
    public static class OrchardStarter {
@@ -30,17 +27,17 @@ namespace Orchard.Environment {
            // still needs to be called on end request, but that's the host component's job to worry about.
            builder.Register<ContainerProvider>().As<IContainerProvider>().ContainerScoped();

-            builder.Register<PackageManager>().As<IPackageManager>().SingletonScoped();
-            builder.Register<CorePackageLoader>().As<IPackageLoader>().SingletonScoped();
-            builder.Register<ReferencedPackageLoader>().As<IPackageLoader>().SingletonScoped();
-            builder.Register<PrecompiledPackageLoader>().As<IPackageLoader>().SingletonScoped();
-            builder.Register<DynamicPackageLoader>().As<IPackageLoader>().SingletonScoped();
+            builder.Register<ExtensionManager>().As<IExtensionManager>().SingletonScoped();
+            builder.Register<CoreExtensionLoader>().As<IExtensionLoader>().SingletonScoped();
+            builder.Register<ReferencedExtensionLoader>().As<IExtensionLoader>().SingletonScoped();
+            builder.Register<PrecompiledExtensionLoader>().As<IExtensionLoader>().SingletonScoped();
+            builder.Register<DynamicExtensionLoader>().As<IExtensionLoader>().SingletonScoped();

            //builder.Register((ctx, p) => new PackageFolders(MapPaths(p.Named<IEnumerable<string>>("paths"))))
            //    .As<IPackageFolders>()
            //    .WithExtendedProperty("paths", new[] { "~/Packages" })
            //    .SingletonScoped();
-            builder.Register<PackageFolders>().As<IPackageFolders>()
+            builder.Register<ExtensionFolders>().As<IExtensionFolders>()
                .WithArguments(new NamedParameter("paths", new[] { "~/Core", "~/Packages" }))
                .SingletonScoped();

--- a/src/Orchard/Extensions/ExtensionDescriptor.cs
+++ b/src/Orchard/Extensions/ExtensionDescriptor.cs
@@ -1,11 +1,5 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using Yaml.Grammar;
-
-namespace Orchard.Packages {
-    public class PackageDescriptor {
+namespace Orchard.Extensions {
+    public class ExtensionDescriptor {
        public string Location { get; set; }
        public string Name { get; set; }

--- a/src/Orchard/Extensions/ExtensionEntry.cs
+++ b/src/Orchard/Extensions/ExtensionEntry.cs
@@ -1,12 +1,10 @@
 using System;
 using System.Collections.Generic;
-using System.Linq;
 using System.Reflection;
-using System.Text;

-namespace Orchard.Packages {
-    public class PackageEntry {
-        public PackageDescriptor Descriptor { get; set; }
+namespace Orchard.Extensions {
+    public class ExtensionEntry {
+        public ExtensionDescriptor Descriptor { get; set; }
        public Assembly Assembly { get; set; }
        public IEnumerable<Type> ExportedTypes { get; set; }
    }
--- a/src/Orchard/Extensions/ExtensionFolders.cs
+++ b/src/Orchard/Extensions/ExtensionFolders.cs
@@ -1,13 +1,11 @@
-using System;
-using System.Collections;
-using System.Collections.Generic;
+using System.Collections.Generic;
 using System.IO;
 using System.Linq;
 using System.Web.Hosting;
 using Yaml.Grammar;

-namespace Orchard.Packages {
-    public interface IPackageFolders {
+namespace Orchard.Extensions {
+    public interface IExtensionFolders {
        IEnumerable<string> ListNames();
        ParseResult ParseManifest(string name);
    }
@@ -18,10 +16,10 @@ namespace Orchard.Packages {
        public YamlDocument YamlDocument { get; set; }
    }

-    public class PackageFolders : IPackageFolders {
+    public class ExtensionFolders : IExtensionFolders {
        private readonly IEnumerable<string> _paths;

-        public PackageFolders(IEnumerable<string> paths) {
+        public ExtensionFolders(IEnumerable<string> paths) {
            _paths = paths;
        }

@@ -34,8 +32,6 @@ namespace Orchard.Packages {

        }

-
-
        public IEnumerable<string> ListNames() {
            foreach (var path in _paths) {
                foreach (var directoryName in Directory.GetDirectories(GetPhysicalPath(path))) {
@@ -47,12 +43,12 @@ namespace Orchard.Packages {

        public ParseResult ParseManifest(string name) {
            foreach (var path in _paths) {
-                var packageDirectoryPath = Path.Combine(GetPhysicalPath(path), name);
-                var packageManifestPath = Path.Combine(packageDirectoryPath, "Package.txt");
-                if (!File.Exists(packageManifestPath)) {
+                var extensionDirectoryPath = Path.Combine(GetPhysicalPath(path), name);
+                var extensionManifestPath = Path.Combine(extensionDirectoryPath, "Package.txt");
+                if (!File.Exists(extensionManifestPath)) {
                    continue;
                }
-                var yamlStream = YamlParser.Load(packageManifestPath);
+                var yamlStream = YamlParser.Load(extensionManifestPath);
                return new ParseResult {
                    Location = path,
                    Name = name,
--- a/src/Orchard/Extensions/ExtensionManager.cs
+++ b/src/Orchard/Extensions/ExtensionManager.cs
@@ -1,26 +1,26 @@
 using System.Collections.Generic;
 using System.Linq;
-using Orchard.Packages.Loaders;
+using Orchard.Extensions.Loaders;
 using Yaml.Grammar;

-namespace Orchard.Packages {
-    public interface IPackageManager {
-        IEnumerable<PackageDescriptor> AvailablePackages();
-        IEnumerable<PackageEntry> ActivePackages();
+namespace Orchard.Extensions {
+    public interface IExtensionManager {
+        IEnumerable<ExtensionDescriptor> AvailableExtensions();
+        IEnumerable<ExtensionEntry> ActiveExtensions();
    }

-    public class PackageManager : IPackageManager {
-        private readonly IPackageFolders _folders;
-        private readonly IEnumerable<IPackageLoader> _loaders;
-        private IEnumerable<PackageEntry> _activePackages;
+    public class ExtensionManager : IExtensionManager {
+        private readonly IExtensionFolders _folders;
+        private readonly IEnumerable<IExtensionLoader> _loaders;
+        private IEnumerable<ExtensionEntry> _activeExtensions;

-        public PackageManager(IPackageFolders folders, IEnumerable<IPackageLoader> loaders) {
+        public ExtensionManager(IExtensionFolders folders, IEnumerable<IExtensionLoader> loaders) {
            _folders = folders;
            _loaders = loaders.OrderBy(x => x.Order);
        }


-        public IEnumerable<PackageDescriptor> AvailablePackages() {
+        public IEnumerable<ExtensionDescriptor> AvailableExtensions() {
            var names = _folders.ListNames();
            foreach (var name in names) {
                var parseResult = _folders.ParseManifest(name);
@@ -30,7 +30,7 @@ namespace Orchard.Packages {
                    .ToDictionary(x => ((Scalar)x.Key).Text, x => x.Value);


-                yield return new PackageDescriptor {
+                yield return new ExtensionDescriptor {
                    Location = parseResult.Location,
                    Name = name,
                    DisplayName = GetValue(fields, "name"),
@@ -48,21 +48,21 @@ namespace Orchard.Packages {
            return fields.TryGetValue(key, out value) ? value.ToString() : null;
        }

-        public IEnumerable<PackageEntry> ActivePackages() {
-            if (_activePackages == null) {
-                _activePackages = BuildActivePackages().ToList();
+        public IEnumerable<ExtensionEntry> ActiveExtensions() {
+            if (_activeExtensions == null) {
+                _activeExtensions = BuildActiveExtensions().ToList();
            }
-            return _activePackages;
+            return _activeExtensions;
        }

-        private IEnumerable<PackageEntry> BuildActivePackages() {
-            foreach (var descriptor in AvailablePackages()) {
+        private IEnumerable<ExtensionEntry> BuildActiveExtensions() {
+            foreach (var descriptor in AvailableExtensions()) {
                //TODO: this component needs access to some "current settings" to know which are active
                yield return BuildEntry(descriptor);
            }
        }

-        private PackageEntry BuildEntry(PackageDescriptor descriptor) {
+        private ExtensionEntry BuildEntry(ExtensionDescriptor descriptor) {
            foreach (var loader in _loaders) {
                var entry = loader.Load(descriptor);
                if (entry != null)
--- a/src/Orchard/Extensions/Loaders/CoreExtensionLoader.cs
+++ b/src/Orchard/Extensions/Loaders/CoreExtensionLoader.cs
@@ -1,18 +1,16 @@
 using System;
-using System.Collections.Generic;
 using System.Linq;
 using System.Reflection;
-using System.Text;

-namespace Orchard.Packages.Loaders {
-    public class CorePackageLoader : IPackageLoader {
+namespace Orchard.Extensions.Loaders {
+    public class CoreExtensionLoader : IExtensionLoader {
        public int Order { get { return 1; } }

-        public PackageEntry Load(PackageDescriptor descriptor) {
+        public ExtensionEntry Load(ExtensionDescriptor descriptor) {
            if (descriptor.Location == "~/Core") {

                var assembly = Assembly.Load("Orchard.Core");
-                return new PackageEntry {
+                return new ExtensionEntry {
                    Descriptor = descriptor,
                    Assembly = assembly,
                    ExportedTypes = assembly.GetExportedTypes().Where(x => IsTypeFromPackage(x, descriptor))
@@ -21,7 +19,7 @@ namespace Orchard.Packages.Loaders {
            return null;
        }

-        private static bool IsTypeFromPackage(Type type, PackageDescriptor descriptor) {
+        private static bool IsTypeFromPackage(Type type, ExtensionDescriptor descriptor) {
            return (type.Namespace + ".").StartsWith("Orchard.Core." + descriptor.Name + ".");
        }
    }
--- a/src/Orchard/Extensions/Loaders/DynamicExtensionLoader.cs
+++ b/src/Orchard/Extensions/Loaders/DynamicExtensionLoader.cs
@@ -6,11 +6,11 @@ using System.Reflection;
 using System.Web.Compilation;
 using System.Web.Hosting;

-namespace Orchard.Packages.Loaders {
-    public class DynamicPackageLoader : IPackageLoader {
+namespace Orchard.Extensions.Loaders {
+    public class DynamicExtensionLoader : IExtensionLoader {
        public int Order { get { return 4; } }

-        public PackageEntry Load(PackageDescriptor descriptor) {
+        public ExtensionEntry Load(ExtensionDescriptor descriptor) {
            if (HostingEnvironment.IsHosted == false)
                return null;

@@ -20,12 +20,12 @@ namespace Orchard.Packages.Loaders {
            var options = new CompilerParameters(references.ToArray());

            var locationPath = HostingEnvironment.MapPath(descriptor.Location);
-            var packagePath = Path.Combine(locationPath, descriptor.Name);
+            var extensionPath = Path.Combine(locationPath, descriptor.Name);

-            var fileNames = GetSourceFileNames(packagePath);
+            var fileNames = GetSourceFileNames(extensionPath);
            var results = codeProvider.CompileAssemblyFromFile(options, fileNames.ToArray());

-            return new PackageEntry {
+            return new ExtensionEntry {
                Descriptor = descriptor,
                Assembly = results.CompiledAssembly,
                ExportedTypes = results.CompiledAssembly.GetExportedTypes(),
@@ -41,15 +41,15 @@ namespace Orchard.Packages.Loaders {
        }

        private IEnumerable<string> GetSourceFileNames(string path) {
-            foreach(var file in Directory.GetFiles(path, "*.cs")) {
+            foreach (var file in Directory.GetFiles(path, "*.cs")) {
                yield return file;
            }

-            foreach(var folder in Directory.GetDirectories(path)) {
+            foreach (var folder in Directory.GetDirectories(path)) {
                if (Path.GetFileName(folder).StartsWith("."))
                    continue;

-                foreach(var file in GetSourceFileNames(folder)) {
+                foreach (var file in GetSourceFileNames(folder)) {
                    yield return file;
                }
            }
--- a/src/Orchard/Extensions/Loaders/IExtensionLoader.cs
+++ b/src/Orchard/Extensions/Loaders/IExtensionLoader.cs
@@ -0,0 +1,6 @@
+namespace Orchard.Extensions.Loaders {
+    public interface IExtensionLoader {
+        int Order { get; }
+        ExtensionEntry Load(ExtensionDescriptor descriptor);
+    }
+}
--- a/src/Orchard/Extensions/Loaders/PrecompiledExtensionLoader.cs
+++ b/src/Orchard/Extensions/Loaders/PrecompiledExtensionLoader.cs
@@ -1,14 +1,8 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Reflection;
-using System.Text;
-
-namespace Orchard.Packages.Loaders {
-    public class PrecompiledPackageLoader : IPackageLoader {
+namespace Orchard.Extensions.Loaders {
+    public class PrecompiledExtensionLoader : IExtensionLoader {
        public int Order { get { return 3; } }

-        public PackageEntry Load(PackageDescriptor descriptor) {
+        public ExtensionEntry Load(ExtensionDescriptor descriptor) {
            //var assembly = Assembly.Load(descriptor.Name);
            //return new PackageEntry {
            //    Descriptor = descriptor,
--- a/src/Orchard/Extensions/Loaders/ReferencedExtensionLoader.cs
+++ b/src/Orchard/Extensions/Loaders/ReferencedExtensionLoader.cs
@@ -1,27 +1,24 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
+using System.Linq;
 using System.Reflection;
-using System.Text;
 using System.Web.Compilation;
 using System.Web.Hosting;

-namespace Orchard.Packages.Loaders {
-    public class ReferencedPackageLoader : IPackageLoader {
+namespace Orchard.Extensions.Loaders {
+    public class ReferencedExtensionLoader : IExtensionLoader {
        public int Order { get { return 2; } }

-        public PackageEntry Load(PackageDescriptor descriptor) {
+        public ExtensionEntry Load(ExtensionDescriptor descriptor) {
            if (HostingEnvironment.IsHosted == false)
                return null;

            var assembly = BuildManager.GetReferencedAssemblies()
                .OfType<Assembly>()
-                .FirstOrDefault(x=>x.GetName().Name == descriptor.Name);
+                .FirstOrDefault(x => x.GetName().Name == descriptor.Name);

            if (assembly == null)
                return null;

-            return new PackageEntry {
+            return new ExtensionEntry {
                Descriptor = descriptor,
                Assembly = assembly,
                ExportedTypes = assembly.GetExportedTypes()
--- a/src/Orchard/Mvc/MvcModule.cs
+++ b/src/Orchard/Mvc/MvcModule.cs
@@ -5,25 +5,25 @@ using Autofac.Integration.Web.Mvc;
 using Orchard.Controllers;
 using Orchard.Environment;
 using Orchard.Mvc.Filters;
-using Orchard.Packages;
+using Orchard.Extensions;

 namespace Orchard.Mvc {
    public class MvcModule : Module {
        private readonly ICompositionStrategy _compositionStrategy;
-        private readonly IPackageManager _packageManager;
+        private readonly IExtensionManager _extensionManager;

-        public MvcModule(ICompositionStrategy compositionStrategy, IPackageManager packageManager) {
+        public MvcModule(ICompositionStrategy compositionStrategy, IExtensionManager extensionManager) {
            _compositionStrategy = compositionStrategy;
-            _packageManager = packageManager;
+            _extensionManager = extensionManager;
        }

        protected override void Load(ContainerBuilder moduleBuilder) {
-            var packages = _packageManager.ActivePackages();
-            var assemblies = packages.Select(x => x.Assembly).Concat(new[] { typeof(HomeController).Assembly });
+            var extensions = _extensionManager.ActiveExtensions();
+            var assemblies = extensions.Select(x => x.Assembly).Concat(new[] { typeof(HomeController).Assembly });

            var module = new AutofacControllerModule(assemblies.ToArray()) {
                ActionInvokerType = typeof(FilterResolvingActionInvoker),
-                IdentificationStrategy = new OrchardControllerIdentificationStrategy(packages)
+                IdentificationStrategy = new OrchardControllerIdentificationStrategy(extensions)
            };

            moduleBuilder.RegisterModule(module);
--- a/src/Orchard/Mvc/OrchardControllerIdentificationStrategy.cs
+++ b/src/Orchard/Mvc/OrchardControllerIdentificationStrategy.cs
@@ -3,14 +3,14 @@ using System.Collections.Generic;
 using System.Linq;
 using Autofac;
 using Autofac.Integration.Web.Mvc;
-using Orchard.Packages;
+using Orchard.Extensions;

 namespace Orchard.Mvc {
    public class OrchardControllerIdentificationStrategy : IControllerIdentificationStrategy {
-        private readonly IEnumerable<PackageEntry> _packages;
+        private readonly IEnumerable<ExtensionEntry> _extensions;

-        public OrchardControllerIdentificationStrategy(IEnumerable<PackageEntry> packages) {
-            _packages = packages;
+        public OrchardControllerIdentificationStrategy(IEnumerable<ExtensionEntry> extensions) {
+            _extensions = extensions;
        }

        public Service ServiceForControllerName(string controllerName) {
@@ -21,7 +21,7 @@ namespace Orchard.Mvc {

        public Service ServiceForControllerType(Type controllerType) {
            var controllerNamespace = controllerType.Namespace;
-            var package = _packages.FirstOrDefault(x => x.Assembly == controllerType.Assembly);
+            var extension = _extensions.FirstOrDefault(x => x.Assembly == controllerType.Assembly);
            var assemblySimpleName = controllerType.Assembly.GetName().Name;
            string areaName;
            if (assemblySimpleName == "Orchard.Core" && 
@@ -29,8 +29,8 @@ namespace Orchard.Mvc {

                areaName = controllerNamespace.Split('.').Skip(2).FirstOrDefault();
            }
-            else if (package != null) {
-                areaName = package.Descriptor.Name;
+            else if (extension != null) {
+                areaName = extension.Descriptor.Name;
            }
            else {
                areaName = assemblySimpleName;
--- a/src/Orchard/Mvc/Routes/StandardExtensionRouteProvider.cs
+++ b/src/Orchard/Mvc/Routes/StandardExtensionRouteProvider.cs
@@ -1,18 +1,18 @@
 using System.Collections.Generic;
 using System.Web.Mvc;
 using System.Web.Routing;
-using Orchard.Packages;
+using Orchard.Extensions;

 namespace Orchard.Mvc.Routes {
-    public class StandardPackageRouteProvider : IRouteProvider {
-        private readonly IPackageManager _packageManager;
+    public class StandardExtensionRouteProvider : IRouteProvider {
+        private readonly IExtensionManager _extensionManager;

-        public StandardPackageRouteProvider(IPackageManager packageManager) {
-            _packageManager = packageManager;
+        public StandardExtensionRouteProvider(IExtensionManager extensionManager) {
+            _extensionManager = extensionManager;
        }

        public IEnumerable<RouteDescriptor> GetRoutes() {
-            foreach (var entry in _packageManager.ActivePackages()) {
+            foreach (var entry in _extensionManager.ActiveExtensions()) {
                var areaName = entry.Descriptor.Name;
                var displayName = entry.Descriptor.DisplayName ?? areaName;

--- a/src/Orchard/Orchard.csproj
+++ b/src/Orchard/Orchard.csproj
@@ -100,7 +100,7 @@
    <Compile Include="Mvc\Routes\IRoutePublisher.cs" />
    <Compile Include="Mvc\Routes\IRouteProvider.cs" />
    <Compile Include="Mvc\Routes\DefaultRouteProvider.cs" />
-    <Compile Include="Mvc\Routes\StandardPackageRouteProvider.cs" />
+    <Compile Include="Mvc\Routes\StandardExtensionRouteProvider.cs" />
    <Compile Include="Mvc\Routes\RoutePublisher.cs" />
    <Compile Include="Mvc\Routes\RouteDescriptor.cs" />
    <Compile Include="Utility\ReadOnlyCollectionExtensions.cs" />
@@ -119,6 +119,15 @@
    <Compile Include="Data\Conventions\AttributeCollectionConvention.cs" />
    <Compile Include="Data\Conventions\CascadeAllDeleteOrphanAttribute.cs" />
    <Compile Include="Environment\IOrchardShellEvents.cs" />
+    <Compile Include="Extensions\ExtensionDescriptor.cs" />
+    <Compile Include="Extensions\ExtensionEntry.cs" />
+    <Compile Include="Extensions\ExtensionFolders.cs" />
+    <Compile Include="Extensions\ExtensionManager.cs" />
+    <Compile Include="Extensions\Loaders\CoreExtensionLoader.cs" />
+    <Compile Include="Extensions\Loaders\DynamicExtensionLoader.cs" />
+    <Compile Include="Extensions\Loaders\IExtensionLoader.cs" />
+    <Compile Include="Extensions\Loaders\PrecompiledExtensionLoader.cs" />
+    <Compile Include="Extensions\Loaders\ReferencedExtensionLoader.cs" />
    <Compile Include="IEvents.cs" />
    <Compile Include="Localization\IText.cs" />
    <Compile Include="Localization\LocalizationModule.cs" />
@@ -198,11 +207,6 @@
    <Compile Include="Mvc\ViewPage.cs">
      <SubType>ASPXCodeBehind</SubType>
    </Compile>
-    <Compile Include="Packages\Loaders\DynamicPackageLoader.cs" />
-    <Compile Include="Packages\Loaders\PrecompiledPackageLoader.cs" />
-    <Compile Include="Packages\Loaders\CorePackageLoader.cs" />
-    <Compile Include="Packages\Loaders\IPackageLoader.cs" />
-    <Compile Include="Packages\Loaders\ReferencedPackageLoader.cs" />
    <Compile Include="Security\IAuthenticationService.cs" />
    <Compile Include="Security\Authorizer.cs" />
    <Compile Include="Security\Providers\FormsAuthenticationService.cs" />
@@ -228,10 +232,6 @@
    <Compile Include="UI\Notify\NotifierExtensions.cs" />
    <Compile Include="UI\Notify\NotifyEntry.cs" />
    <Compile Include="UI\Notify\NotifyFilter.cs" />
-    <Compile Include="Packages\PackageEntry.cs" />
-    <Compile Include="Packages\PackageFolders.cs" />
-    <Compile Include="Packages\PackageDescriptor.cs" />
-    <Compile Include="Packages\PackageManager.cs" />
    <Compile Include="Security\CreateUserParams.cs" />
    <Compile Include="Security\IAuthorizationService.cs" />
    <Compile Include="Security\IMembershipService.cs" />
--- a/src/Orchard/Packages/Loaders/IPackageLoader.cs
+++ b/src/Orchard/Packages/Loaders/IPackageLoader.cs
@@ -1,6 +0,0 @@
-namespace Orchard.Packages.Loaders {
-    public interface IPackageLoader {
-        int Order { get; }
-        PackageEntry Load(PackageDescriptor descriptor);
-    }
-}