Rough intermediate state

display and shape are a work in progress
coarse grained service interfaces and relationships forming

--HG--
branch : mvc3p1

src/Orchard.Tests/App.config

@@ -16,7 +16,8 @@
     <assemblyBinding xmlns="urn:schemas-microsoft-com:asm.v1">
       <dependentAssembly>
         <assemblyIdentity name="System.Web.Mvc" publicKeyToken="31bf3856ad364e35"/>
-        <bindingRedirect oldVersion="1.0.0.0" newVersion="2.0.0.0"/>
+        <bindingRedirect oldVersion="1.0.0.0" newVersion="3.0.0.0"/>
+        <bindingRedirect oldVersion="2.0.0.0" newVersion="3.0.0.0"/>
       </dependentAssembly>
     </assemblyBinding>
   </runtime>

src/Orchard.Tests/DisplayManagement/ArgsUtility.cs

@@ -0,0 +1,33 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Web.Routing;
+using ClaySharp;
+using ClaySharp.Implementation;
+
+namespace Orchard.Tests.DisplayManagement {
+    public static class ArgsUtility {
+        public static INamedEnumerable<T> Named<T>(IDictionary<string, T> args) {
+            return FromDictionary(args);
+        }
+
+        public static INamedEnumerable<object> Named(object args) {
+            return FromDictionary(new RouteValueDictionary(args));
+        }
+        public static INamedEnumerable<T> Empty<T>() {
+            return Arguments.FromT(Enumerable.Empty<T>(), Enumerable.Empty<string>());
+        }
+        public static INamedEnumerable<object> Empty() {
+            return Empty<object>();
+        }
+
+        static INamedEnumerable<T> FromDictionary<T>(IDictionary<string, T> args) { 
+            return Arguments.FromT(args.Values, args.Keys); 
+        }
+
+        public static INamedEnumerable<object> Positional(params object[] args) {
+            return Arguments.From(args, Enumerable.Empty<string>());
+        }
+    }
+}

src/Orchard.Tests/DisplayManagement/DefaultDisplayManagerTests.cs

@@ -0,0 +1,12 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using NUnit.Framework;
+
+namespace Orchard.Tests.DisplayManagement {
+   [TestFixture]
+    public class DefaultDisplayManagerTests {
+      
+    }
+}

src/Orchard.Tests/DisplayManagement/DefaultShapeTableFactoryTests.cs

@@ -0,0 +1,39 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Autofac;
+using NUnit.Framework;
+using Orchard.DisplayManagement;
+
+namespace Orchard.Tests.DisplayManagement {
+    [TestFixture]
+    public class DefaultShapeTableFactoryTests {
+        static IShapeTableFactory CreateShapeTableFactory(Action<ContainerBuilder> config) {
+            var builder = new ContainerBuilder();
+            builder.RegisterType<DefaultShapeTableFactory>().As<IShapeTableFactory>();
+            config(builder);
+            var container = builder.Build();
+            return container.Resolve<IShapeTableFactory>();
+        }
+
+        [Test]
+        public void ShapeTableRecognizesMethodNames() {
+            var stf = CreateShapeTableFactory(cfg => cfg.RegisterType<Test>().As<IShapeProvider>());
+            var shapeTable = stf.CreateShapeTable();
+            Assert.That(shapeTable.Entries.Count(), Is.EqualTo(2));
+            Assert.That(shapeTable.Entries.ContainsKey("Pager"));
+            Assert.That(shapeTable.Entries.ContainsKey("Email"));
+        }
+
+        public class Test : IShapeProvider {
+            public void Pager() {
+            }
+
+            public void Email(string text, string address) {
+            }
+        }
+    }
+
+
+}

src/Orchard.Tests/DisplayManagement/DisplayHelperTests.cs

@@ -0,0 +1,64 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Web.Mvc;
+using ClaySharp;
+using ClaySharp.Implementation;
+using Moq;
+using NUnit.Framework;
+using Orchard.DisplayManagement;
+using Orchard.DisplayManagement.Shapes;
+
+namespace Orchard.Tests.DisplayManagement {
+    [TestFixture]
+    public class DisplayHelperTests {
+        [Test]
+        public void DisplayingShapeWithArgumentsStatically() {
+            var viewContext = new ViewContext();
+
+            var displayManager = new Mock<IDisplayManager>();
+            var shapeFactory = new Mock<IShapeBuilder>();
+
+            var displayHelperFactory = new DisplayHelperFactory(displayManager.Object, shapeFactory.Object);
+            var displayHelper = displayHelperFactory.CreateDisplayHelper(viewContext, null);
+
+            displayHelper.Invoke("Pager", ArgsUtility.Positional(1, 2, 3, 4));
+
+            shapeFactory.Verify(sf=>sf.Build("Pager", It.IsAny<INamedEnumerable<object>>()));
+            displayManager.Verify(dm => dm.Execute(It.IsAny<Shape>(), viewContext, null));
+        }
+        [Test]
+        public void DisplayingShapeWithArgumentsDynamically() {
+            var viewContext = new ViewContext();
+
+            var displayManager = new Mock<IDisplayManager>();
+            var shapeFactory = new Mock<IShapeBuilder>();
+
+            var displayHelperFactory = new DisplayHelperFactory(displayManager.Object, shapeFactory.Object);
+            var display = (dynamic)displayHelperFactory.CreateDisplayHelper(viewContext, null);
+
+            display.Pager(1, 2, 3, 4);
+
+            shapeFactory.Verify(sf => sf.Build("Pager", It.IsAny<INamedEnumerable<object>>()));
+            displayManager.Verify(dm => dm.Execute(It.IsAny<Shape>(), viewContext, null));
+        }
+
+
+
+        [Test]
+        public void UsingDisplayAsFunctionAndPassingInTheShape() {
+            var viewContext = new ViewContext();
+
+            var displayManager = new Mock<IDisplayManager>();
+            var shapeFactory = new Mock<IShapeBuilder>();
+
+            var displayHelperFactory = new DisplayHelperFactory(displayManager.Object, shapeFactory.Object);
+            var display = (dynamic)displayHelperFactory.CreateDisplayHelper(viewContext, null);
+            var outline = new Shape { Attributes = new ShapeAttributes { Type = "Outline" } };
+            display(outline);
+
+            displayManager.Verify(dm => dm.Execute(outline, viewContext, null));
+        }
+    }
+}

src/Orchard.Tests/DisplayManagement/ShapeFactoryTests.cs

@@ -0,0 +1,37 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Autofac;
+using NUnit.Framework;
+using Orchard.DisplayManagement;
+using Orchard.DisplayManagement.Shapes;
+
+namespace Orchard.Tests.DisplayManagement {
+    [TestFixture]
+    public class DefaultShapeBuilderTests {
+        private IContainer _container;
+
+        [SetUp]
+        public void Init() {
+            var builder = new ContainerBuilder();
+            builder.RegisterType<DefaultShapeBuilder>().As<IShapeBuilder>();
+            _container = builder.Build();
+        }
+
+        
+        [Test]
+        public void ShapeHasAttributesType() {
+            var factory = _container.Resolve<IShapeBuilder>();
+            dynamic foo = factory.Build("Foo", ArgsUtility.Empty());
+            ShapeAttributes attributes = foo.Attributes;
+            Assert.That(attributes.Type, Is.EqualTo("Foo"));
+        }
+
+        [Test]
+        public void CreateShapeWithNamedArguments() {
+            var factory = _container.Resolve<IShapeBuilder>();
+            var foo = factory.Build("Foo", ArgsUtility.Named(new { one = 1, two = "dos" }));
+        }
+    }
+}

src/Orchard.Tests/DisplayManagement/ShapeHelperTests.cs

@@ -0,0 +1,55 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Autofac;
+using NUnit.Framework;
+using Orchard.DisplayManagement;
+using Orchard.DisplayManagement.Shapes;
+
+namespace Orchard.Tests.DisplayManagement {
+    [TestFixture]
+    public class ShapeHelperTests {
+        private IContainer _container;
+
+        [SetUp]
+        public void Init() {
+            var builder = new ContainerBuilder();
+            builder.RegisterType<ShapeHelperFactory>().As<IShapeHelperFactory>();
+            builder.RegisterType<DefaultShapeBuilder>().As<IShapeBuilder>();
+            _container = builder.Build();
+
+        }
+
+        [Test]
+        public void CreatingNewShapeTypeByName() {
+            dynamic shape = _container.Resolve<IShapeHelperFactory>().CreateShapeHelper();
+
+            var alpha = shape.Alpha();
+
+            Assert.That(alpha.Attributes.Type, Is.EqualTo("Alpha"));
+        }
+
+        [Test]
+        public void CreatingShapeWithAdditionalNamedParameters() {
+            dynamic shape = _container.Resolve<IShapeHelperFactory>().CreateShapeHelper();
+
+            var alpha = shape.Alpha(one: 1, two: "dos");
+
+            Assert.That(alpha.Attributes.Type, Is.EqualTo("Alpha"));
+            Assert.That(alpha.one, Is.EqualTo(1));
+            Assert.That(alpha.two, Is.EqualTo("dos"));
+        }
+
+        [Test]
+        public void WithPropertyBearingObjectInsteadOfNamedParameters() {
+            dynamic shape = _container.Resolve<IShapeHelperFactory>().CreateShapeHelper();
+
+            var alpha = shape.Alpha(new { one = 1, two = "dos" });
+
+            Assert.That(alpha.Attributes.Type, Is.EqualTo("Alpha"));
+            Assert.That(alpha.one, Is.EqualTo(1));
+            Assert.That(alpha.two, Is.EqualTo("dos"));
+        }
+    }
+}

src/Orchard.Tests/DisplayManagement/SubsystemTests.cs

@@ -0,0 +1,57 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Web;
+using System.Web.Mvc;
+using Autofac;
+using NUnit.Framework;
+using Orchard.DisplayManagement;
+using Orchard.DisplayManagement.Secondary;
+using Orchard.DisplayManagement.Shapes;
+
+namespace Orchard.Tests.DisplayManagement {
+    [TestFixture]
+    public class SubsystemTests {
+        private IContainer _container;
+
+        [SetUp]
+        public void Init() {
+            var builder = new ContainerBuilder();
+            builder.RegisterType<DefaultDisplayManager>().As<IDisplayManager>();
+            builder.RegisterType<DefaultShapeBuilder>().As<IShapeBuilder>();
+            builder.RegisterType<DisplayHelperFactory>().As<IDisplayHelperFactory>();
+            builder.RegisterType<ShapeHelperFactory>().As<IShapeHelperFactory>();
+            builder.RegisterType<DefaultShapeTableFactory>().As<IShapeTableFactory>();
+            builder.RegisterType<SimpleShapes>().As<IShapeProvider>();
+            _container = builder.Build();
+        }
+
+        public class SimpleShapes : IShapeProvider {
+            public IHtmlString Something() {
+                return new HtmlString("<br/>");
+            }
+
+            public IHtmlString Pager() {
+                return new HtmlString("<div>hello</div>");
+            }
+        }
+
+        [Test]
+        public void RenderingSomething() {
+            var viewContext = new ViewContext();
+            
+            dynamic Display = _container.Resolve<IDisplayHelperFactory>().CreateDisplayHelper(viewContext, null);
+
+            dynamic New = _container.Resolve<IShapeHelperFactory>().CreateShapeHelper();
+
+            var result1 = Display.Something();
+            var result2 = ((DisplayHelper)Display).ShapeExecute((Shape)New.Pager());
+            
+            Display(New.Pager());
+
+            Assert.That(result1.ToString(), Is.EqualTo("<br/>"));
+            Assert.That(result2.ToString(), Is.EqualTo("<div>hello</div>"));
+        }
+    }
+}

src/Orchard.Tests/Orchard.Framework.Tests.csproj

@@ -75,10 +75,12 @@
       <SpecificVersion>False</SpecificVersion>
       <HintPath>..\..\lib\Castle Windsor 2.0\bin\Castle.DynamicProxy2.dll</HintPath>
     </Reference>
+    <Reference Include="ClaySharp, Version=1.0.0.0, Culture=neutral, processorArchitecture=MSIL" />
     <Reference Include="FluentNHibernate, Version=1.0.0.593, Culture=neutral, PublicKeyToken=8aa435e3cb308880, processorArchitecture=MSIL">
       <SpecificVersion>False</SpecificVersion>
       <HintPath>..\..\lib\fluentnhibernate\FluentNHibernate.dll</HintPath>
     </Reference>
+    <Reference Include="Microsoft.CSharp" />
     <Reference Include="Moq, Version=4.0.812.4, Culture=neutral, PublicKeyToken=69f491c39445e920, processorArchitecture=MSIL">
       <SpecificVersion>False</SpecificVersion>
       <HintPath>..\..\lib\moq\Moq.dll</HintPath>
@@ -190,6 +192,13 @@
     <Compile Include="Data\Builders\SessionFactoryBuilderTests.cs" />
     <Compile Include="Data\RepositoryTests.cs" />
     <Compile Include="Data\StubLocator.cs" />
+    <Compile Include="DisplayManagement\ArgsUtility.cs" />
+    <Compile Include="DisplayManagement\DefaultDisplayManagerTests.cs" />
+    <Compile Include="DisplayManagement\DefaultShapeTableFactoryTests.cs" />
+    <Compile Include="DisplayManagement\DisplayHelperTests.cs" />
+    <Compile Include="DisplayManagement\ShapeFactoryTests.cs" />
+    <Compile Include="DisplayManagement\SubsystemTests.cs" />
+    <Compile Include="DisplayManagement\ShapeHelperTests.cs" />
     <Compile Include="Environment\AutofacUtil\AutofacTests.cs" />
     <Compile Include="Environment\AutofacUtil\DynamicProxy2\DynamicProxyTests.cs" />
     <Compile Include="Environment\Extensions\ExtensionLoaderCoordinatorTests.cs" />
@@ -270,7 +279,9 @@
     </ProjectReference>
   </ItemGroup>
   <ItemGroup>
-    <None Include="App.config" />
+    <None Include="App.config">
+      <SubType>Designer</SubType>
+    </None>
   </ItemGroup>
   <ItemGroup>
     <EmbeddedResource Include="Environment\Extensions\FoldersData\Sample1\Module.txt" />