yv01p/Umbraco-CMS
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Completes: U4-2742 Remove legacy xsltExtensions.config - xslt extensions are configured using attributes

Browse Source
This commit is contained in:
Shannon
2013-08-29 17:14:34 +10:00
parent cd7f737fa6
commit 733b6aa945
27 changed files with 236 additions and 373 deletions
Download Patch File Download Diff File Expand all files Collapse all files

10
src/Umbraco.Core/IO/SystemFiles.cs
View File

@@ -51,15 +51,7 @@ namespace Umbraco.Core.IO
return SystemDirectories.Config + "/dashboard.config";
}
}
public static string XsltextensionsConfig
{
get
{
return SystemDirectories.Config + "/xsltextensions.config";
}
}
public static string SkinningXml
{
get

17
src/Umbraco.Core/Macros/XsltExtension.cs Normal file
View File

@@ -0,0 +1,17 @@
namespace Umbraco.Core.Macros
{
/// <summary>
/// Encapsulates what an xslt extension object is when used for macros
/// </summary>
internal sealed class XsltExtension
{
public XsltExtension(string ns, object extensionObject)
{
Namespace = ns;
ExtensionObject = extensionObject;
}
public string Namespace { get; private set; }
public object ExtensionObject { get; private set; }
}
}

34
src/Umbraco.Core/Macros/XsltExtensionAttribute.cs Normal file
View File

@@ -0,0 +1,34 @@
using System;
using System.Security.Permissions;
using System.Web;
namespace Umbraco.Core.Macros
{
/// <summary>
/// Allows App_Code XSLT extensions to be declared using the [XsltExtension] class attribute.
/// </summary>
/// <remarks>
/// An optional XML namespace can be specified using [XsltExtension("MyNamespace")].
/// </remarks>
[AttributeUsage(AttributeTargets.Class)]
[AspNetHostingPermission(SecurityAction.Demand, Level = AspNetHostingPermissionLevel.Medium, Unrestricted = false)]
public class XsltExtensionAttribute : Attribute
{
public XsltExtensionAttribute()
{
Namespace = String.Empty;
}
public XsltExtensionAttribute(string ns)
{
Namespace = ns;
}
public string Namespace { get; set; }
public override string ToString()
{
return Namespace;
}
}
}

59
src/Umbraco.Core/Macros/XsltExtensionsResolver.cs Normal file
View File

@@ -0,0 +1,59 @@
using System;
using System.Collections.Generic;
using Umbraco.Core.ObjectResolution;
namespace Umbraco.Core.Macros
{
/// <summary>
/// Used to resolve all xslt extension plugins
/// </summary>
internal sealed class XsltExtensionsResolver : LazyManyObjectsResolverBase<XsltExtensionsResolver, XsltExtension>
{
/// <summary>
/// Constructor
/// </summary>
/// <param name="packageActions"></param>
internal XsltExtensionsResolver(Func<IEnumerable<Type>> packageActions)
: base(packageActions, ObjectLifetimeScope.Application)
{
}
/// <summary>
/// Returns the list of all xslt extensions
/// </summary>
public IEnumerable<XsltExtension> XsltExtensions
{
get { return Values; }
}
protected override IEnumerable<XsltExtension> CreateInstances()
{
var result = new HashSet<XsltExtension>();
foreach (var xsltType in InstanceTypes)
{
var tpAttributes = xsltType.GetCustomAttributes(typeof(XsltExtensionAttribute), true);
foreach (XsltExtensionAttribute tpAttribute in tpAttributes)
{
var ns = string.IsNullOrEmpty(tpAttribute.Namespace) == false
? tpAttribute.Namespace
: xsltType.FullName;
result.Add(new XsltExtension(ns, Activator.CreateInstance(xsltType)));
}
}
return result;
}
/// <summary>
/// We override this because really there's no limit to the type that can be used here
/// </summary>
/// <param name="value"></param>
protected override void EnsureCorrectType(Type value)
{
//do nothing.
}
}
}

2
src/Umbraco.Core/ObjectResolution/ManyObjectsResolverBase.cs
View File

@@ -488,7 +488,7 @@ namespace Umbraco.Core.ObjectResolution
/// </summary>
/// <param name="value">The type to test.</param>
/// <exception cref="InvalidOperationException">the type is not a valid type for the resolver.</exception>
protected void EnsureCorrectType(Type value)
protected virtual void EnsureCorrectType(Type value)
{
if (!TypeHelper.IsTypeAssignableFrom<TResolved>(value))
throw new InvalidOperationException(string.Format(

3
src/Umbraco.Core/Umbraco.Core.csproj
View File

@@ -182,6 +182,9 @@
<Compile Include="IApplicationEventHandler.cs" />
<Compile Include="IO\ResizedImage.cs" />
<Compile Include="IO\UmbracoMediaFile.cs" />
<Compile Include="Macros\XsltExtension.cs" />
<Compile Include="Macros\XsltExtensionAttribute.cs" />
<Compile Include="Macros\XsltExtensionsResolver.cs" />
<Compile Include="Manifest\ManifestBuilder.cs" />
<Compile Include="Manifest\ManifestParser.cs" />
<Compile Include="Manifest\ManifestValidatorConverter.cs" />

2
src/Umbraco.Tests/Resolvers/ActionsResolverTests.cs
View File

@@ -8,7 +8,7 @@ using umbraco.interfaces;
namespace Umbraco.Tests.Resolvers
{
[TestFixture]
[TestFixture]
public class ActionsResolverTests
{
[SetUp]

78
src/Umbraco.Tests/Resolvers/XsltExtensionsResolverTests.cs Normal file
View File

@@ -0,0 +1,78 @@
using System.Linq;
using NUnit.Framework;
using Umbraco.Core;
using Umbraco.Core.Macros;
using Umbraco.Core.ObjectResolution;
using Umbraco.Tests.TestHelpers;
using Umbraco.Web;
using Umbraco.Web.Macros;
using umbraco;
namespace Umbraco.Tests.Resolvers
{
[TestFixture]
public class XsltExtensionsResolverTests
{
[SetUp]
public void Initialize()
{
TestHelper.SetupLog4NetForTests();
ActionsResolver.Reset();
// this ensures it's reset
PluginManager.Current = new PluginManager(false);
// for testing, we'll specify which assemblies are scanned for the PluginTypeResolver
PluginManager.Current.AssembliesToScan = new[]
{
this.GetType().Assembly // this assembly only
};
}
[TearDown]
public void TearDown()
{
ActionsResolver.Reset();
PluginManager.Current = null;
}
// NOTE
// ManyResolverTests ensure that we'll get our actions back and ActionsResolver works,
// so all we're testing here is that plugin manager _does_ find our actions
// which should be ensured by PlugingManagerTests anyway, so this is useless?
// maybe not as it seems to handle the "instance" thing... so we test that we respect the singleton?
[Test]
public void Find_All_Extensions()
{
XsltExtensionsResolver.Current = new XsltExtensionsResolver(
() => PluginManager.Current.ResolveXsltExtensions());
Resolution.Freeze();
var extensions = XsltExtensionsResolver.Current.XsltExtensions;
Assert.AreEqual(3, extensions.Count());
Assert.IsTrue(extensions.Select(x => x.ExtensionObject.GetType()).Contains(typeof (XsltEx1)));
Assert.IsTrue(extensions.Select(x => x.ExtensionObject.GetType()).Contains(typeof(XsltEx2)));
Assert.AreEqual("test1", extensions.Single(x => x.ExtensionObject.GetType() == typeof(XsltEx1)).Namespace);
Assert.AreEqual("test2", extensions.Single(x => x.ExtensionObject.GetType() == typeof(XsltEx2)).Namespace);
}
#region Classes for tests
[Umbraco.Core.Macros.XsltExtension("test1")]
public class XsltEx1
{
}
//test with legacy one
[umbraco.XsltExtension("test2")]
public class XsltEx2
{
}
#endregion
}
}

1
src/Umbraco.Tests/Umbraco.Tests.csproj
View File

@@ -218,6 +218,7 @@
<Compile Include="PropertyEditors\DropDownPropertyPreValueEditorTests.cs" />
<Compile Include="PropertyEditors\EnsureUniqueValuesValidatorTest.cs" />
<Compile Include="PropertyEditors\PropertyEditorValueEditorTests.cs" />
<Compile Include="Resolvers\XsltExtensionsResolverTests.cs" />
<Compile Include="Services\PackagingServiceTests.cs" />
<Compile Include="Services\PerformanceTests.cs" />
<Compile Include="Services\PreValueConverterTests.cs" />

4
src/Umbraco.Web.UI/Umbraco.Web.UI.csproj
View File

@@ -623,9 +623,6 @@
<None Include="Config\EmbeddedMedia.Release.config">
<DependentUpon>EmbeddedMedia.config</DependentUpon>
</None>
<None Include="Config\xsltExtensions.Release.config">
<DependentUpon>xsltExtensions.config</DependentUpon>
</None>
<None Include="Config\UrlRewriting.Release.config">
<DependentUpon>UrlRewriting.config</DependentUpon>
</None>
@@ -2599,7 +2596,6 @@
<Content Include="Config\umbracoSettings.config">
<SubType>Designer</SubType>
</Content>
<Content Include="Config\xsltExtensions.config" />
<Content Include="Config\UrlRewriting.config" />
<Content Include="Config\log4net.config" />
<Content Include="Config\FileSystemProviders.config" />

12
src/Umbraco.Web.UI/config/xsltExtensions.Release.config
View File

@@ -1,12 +0,0 @@
<?xml version="1.0" encoding="utf-8" ?>
<XsltExtensions>
<!-- This file is used to register 3rd party XSLT extensions (methods you can execute from XSLT, like umbraco.library:NiceUrl) -->
<!-- <ext assembly="assemblyName" type="assemblyName.namespace.type" alias="custom" /> -->
<ext assembly="umbraco" type="umbraco.presentation.xslt.Exslt.ExsltCommon" alias="Exslt.ExsltCommon" />
<ext assembly="umbraco" type="umbraco.presentation.xslt.Exslt.ExsltDatesAndTimes" alias="Exslt.ExsltDatesAndTimes" />
<ext assembly="umbraco" type="umbraco.presentation.xslt.Exslt.ExsltMath" alias="Exslt.ExsltMath" />
<ext assembly="umbraco" type="umbraco.presentation.xslt.Exslt.ExsltRegularExpressions" alias="Exslt.ExsltRegularExpressions" />
<ext assembly="umbraco" type="umbraco.presentation.xslt.Exslt.ExsltStrings" alias="Exslt.ExsltStrings" />
<ext assembly="umbraco" type="umbraco.presentation.xslt.Exslt.ExsltSets" alias="Exslt.ExsltSets" />
<ext assembly="UmbracoExamine" type="UmbracoExamine.XsltExtensions" alias="Examine" />
</XsltExtensions>

12
src/Umbraco.Web.UI/config/xsltExtensions.config
View File

@@ -1,12 +0,0 @@
<?xml version="1.0" encoding="utf-8"?>
<XsltExtensions>
<!-- This file is used to register 3rd party XSLT extensions (methods you can execute from XSLT, like umbraco.library:NiceUrl) -->
<!-- <ext assembly="assemblyName" type="assemblyName.namespace.type" alias="custom" /> -->
<ext assembly="umbraco" type="umbraco.presentation.xslt.Exslt.ExsltCommon" alias="Exslt.ExsltCommon" />
<ext assembly="umbraco" type="umbraco.presentation.xslt.Exslt.ExsltDatesAndTimes" alias="Exslt.ExsltDatesAndTimes" />
<ext assembly="umbraco" type="umbraco.presentation.xslt.Exslt.ExsltMath" alias="Exslt.ExsltMath" />
<ext assembly="umbraco" type="umbraco.presentation.xslt.Exslt.ExsltRegularExpressions" alias="Exslt.ExsltRegularExpressions" />
<ext assembly="umbraco" type="umbraco.presentation.xslt.Exslt.ExsltStrings" alias="Exslt.ExsltStrings" />
<ext assembly="umbraco" type="umbraco.presentation.xslt.Exslt.ExsltSets" alias="Exslt.ExsltSets" />
<ext assembly="UmbracoExamine" type="UmbracoExamine.XsltExtensions" alias="Examine" />
</XsltExtensions>

77
src/Umbraco.Web.UI/install/steps/Renaming.ascx.cs
View File

@@ -12,10 +12,7 @@ namespace Umbraco.Web.UI.Install.Steps
private bool _changesNeeded = false;
protected void Page_Load(object sender, EventArgs e)
{
// check xslt extensions
identifyResult.Text += CheckExtensionPaths("xsltExtensions.config", "XSLT Extension");
{
// check access.xml file
identifyResult.Text += CheckAccessFile();
@@ -49,54 +46,7 @@ namespace Umbraco.Web.UI.Install.Steps
{
return File.Exists(_newAccessFilePath);
}
private string CheckExtensionPaths(string filename, string extensionName)
{
string tempResult = "";
foreach (XmlNode ext in GetExtensions(filename, "ext"))
{
if (ext.Attributes.GetNamedItem("assembly") != null &&
ext.Attributes.GetNamedItem("assembly").Value.StartsWith("/bin/"))
{
tempResult += String.Format("<li>{0} with Alias '{1}' has assembly reference that contains /bin/. That part needs to be removed</li>",
extensionName,
ext.Attributes.GetNamedItem("alias").Value);
}
}
if (String.IsNullOrEmpty(tempResult))
{
tempResult = String.Format("<li>{0}s are all good. No changes needed</li>", extensionName);
}
else
{
_changesNeeded = true;
}
return tempResult;
}
private static void UpdateExtensionPaths(string filename)
{
filename = IOHelper.MapPath(SystemDirectories.Config + "/" + filename);
var xsltExt = new XmlDocument();
xsltExt.Load(filename);
foreach (XmlNode ext in xsltExt.SelectNodes("//ext"))
{
if (ext.Attributes.GetNamedItem("assembly") != null &&
ext.Attributes.GetNamedItem("assembly").Value.StartsWith("/bin/"))
{
ext.Attributes.GetNamedItem("assembly").Value =
ext.Attributes.GetNamedItem("assembly").Value.Substring(5);
}
}
xsltExt.Save(filename);
}
protected void UpdateChangesClick(object sender, EventArgs e)
{
bool succes = true;
@@ -115,19 +65,7 @@ namespace Umbraco.Web.UI.Install.Steps
progressText += String.Format("<li>Error renaming access file: {0}</li>", ee.ToString());
succes = false;
}
}
// update xslt exts
try
{
UpdateExtensionPaths("xsltExtensions.config");
progressText += "<li>xsltExtensions.config ensured.</li>";
}
catch (Exception ee)
{
progressText += String.Format("<li>Error updating xsltExtensions.config: {0}</li>", ee.ToString());
succes = false;
}
}
string resultClass = succes ? "success" : "error";
resultText.Text = String.Format("<div class=\"{0}\"><p>{1}</p></div>",
@@ -137,14 +75,5 @@ namespace Umbraco.Web.UI.Install.Steps
init.Visible = false;
}
private XmlNodeList GetExtensions(string filename, string elementName)
{
// Load the XSLT extensions configuration
var xsltExt = new XmlDocument();
xsltExt.Load(IOHelper.MapPath(SystemDirectories.Config + "/" + filename));
return xsltExt.SelectNodes("//" + elementName);
}
}
}

2
src/Umbraco.Web/PluginManagerExtensions.cs
View File

@@ -66,7 +66,7 @@ namespace Umbraco.Web
/// <returns></returns>
internal static IEnumerable<Type> ResolveXsltExtensions(this PluginManager resolver)
{
return resolver.ResolveAttributedTypes<XsltExtensionAttribute>();
return resolver.ResolveAttributedTypes<Umbraco.Core.Macros.XsltExtensionAttribute>();
}
/// <summary>

4
src/Umbraco.Web/WebBootManager.cs
View File

@@ -10,11 +10,13 @@ using Umbraco.Core;
using Umbraco.Core.Configuration;
using Umbraco.Core.Dictionary;
using Umbraco.Core.Logging;
using Umbraco.Core.Macros;
using Umbraco.Core.ObjectResolution;
using Umbraco.Core.Profiling;
using Umbraco.Core.PropertyEditors;
using Umbraco.Core.Sync;
using Umbraco.Web.Dictionary;
using Umbraco.Web.Macros;
using Umbraco.Web.Media;
using Umbraco.Web.Media.ThumbnailProviders;
using Umbraco.Web.Models;
@@ -246,6 +248,8 @@ namespace Umbraco.Web
{
base.InitializeResolvers();
XsltExtensionsResolver.Current = new XsltExtensionsResolver(() => PluginManager.Current.ResolveXsltExtensions());
//set the default RenderMvcController
DefaultRenderMvcControllerResolver.Current = new DefaultRenderMvcControllerResolver(typeof(RenderMvcController));

45
src/Umbraco.Web/umbraco.presentation/XsltExtensionAttribute.cs
View File

@@ -4,31 +4,26 @@ using System.Web;
namespace umbraco
{
/// <summary>
/// Allows App_Code XSLT extensions to be declared using the [XsltExtension] class attribute.
/// </summary>
/// <remarks>
/// An optional XML namespace can be specified using [XsltExtension("MyNamespace")].
/// </remarks>
[AttributeUsage(AttributeTargets.Class)]
[AspNetHostingPermission(SecurityAction.Demand, Level = AspNetHostingPermissionLevel.Medium, Unrestricted = false)]
public class XsltExtensionAttribute : Attribute
{
public XsltExtensionAttribute()
{
Namespace = String.Empty;
}
/// <summary>
/// Allows App_Code XSLT extensions to be declared using the [XsltExtension] class attribute.
/// </summary>
/// <remarks>
/// An optional XML namespace can be specified using [XsltExtension("MyNamespace")].
/// </remarks>
[AttributeUsage(AttributeTargets.Class)]
[AspNetHostingPermission(SecurityAction.Demand, Level = AspNetHostingPermissionLevel.Medium, Unrestricted = false)]
[Obsolete("Use Umbraco.Core.Macros.XsltExtensionAttribute instead")]
public class XsltExtensionAttribute : Umbraco.Core.Macros.XsltExtensionAttribute
{
public XsltExtensionAttribute() : base()
{
}
public XsltExtensionAttribute(string ns)
{
Namespace = ns;
}
public XsltExtensionAttribute(string ns) : base(ns)
{
}
public string Namespace { get; set; }
public override string ToString()
{
return Namespace;
}
}
}
}

131
src/Umbraco.Web/umbraco.presentation/macro.cs
View File

@@ -1,8 +1,6 @@
using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.Net;
using System.Net.Security;
@@ -17,19 +15,17 @@ using System.Web.UI.WebControls;
using System.Xml;
using System.Xml.XPath;
using System.Xml.Xsl;
using StackExchange.Profiling;
using Umbraco.Core;
using Umbraco.Core.Cache;
using Umbraco.Core.Events;
using Umbraco.Core.IO;
using Umbraco.Core.Logging;
using Umbraco.Core.Macros;
using Umbraco.Core.Profiling;
using Umbraco.Web;
using Umbraco.Web.Cache;
using Umbraco.Web.Macros;
using Umbraco.Web.Templates;
using umbraco.BusinessLogic;
using umbraco.cms.businesslogic;
using umbraco.cms.businesslogic.macro;
using umbraco.cms.businesslogic.member;
using umbraco.DataLayer;
@@ -38,6 +34,7 @@ using umbraco.presentation.templateControls;
using Content = umbraco.cms.businesslogic.Content;
using Macro = umbraco.cms.businesslogic.macro.Macro;
using MacroErrorEventArgs = Umbraco.Core.Events.MacroErrorEventArgs;
using System.Linq;
namespace umbraco
{
@@ -161,12 +158,6 @@ namespace umbraco
private const string XsltExtensionsCacheKey = "UmbracoXsltExtensions";
private static readonly string XsltExtensionsConfig =
IOHelper.MapPath(SystemDirectories.Config + "/xsltExtensions.config");
private static readonly Func<CacheDependency> _xsltExtensionsDependency =
() => new CacheDependency(XsltExtensionsConfig);
/// <summary>
/// Creates an empty macro object.
/// </summary>
@@ -1063,122 +1054,10 @@ namespace umbraco
/// <returns>A dictionary of name/extension instance pairs.</returns>
public static Dictionary<string, object> GetXsltExtensions()
{
// zb-00041 #29966 : cache the extensions
// We could cache the extensions in a static variable but then the cache
// would not be refreshed when the .config file is modified. An application
// restart would be required. Better use the cache and add a dependency.
// SD: The only reason the above statement might be true is because the xslt extension .config file is not a
// real config file!! if it was, we wouldn't have this issue. Having these in a static variable would be preferred!
// If you modify a config file, the app restarts and thus all static variables are reset.
// Having this stuff in cache just adds to the gigantic amount of cache data and will cause more cache turnover to happen.
return ApplicationContext.Current.ApplicationCache.GetCacheItem(
XsltExtensionsCacheKey,
CacheItemPriority.NotRemovable, // NH 4.7.1, Changing to NotRemovable
null, // no refresh action
_xsltExtensionsDependency(), // depends on the .config file
TimeSpan.FromDays(1), // expires in 1 day (?)
GetXsltExtensionsImpl);
return XsltExtensionsResolver.Current.XsltExtensions
.ToDictionary(x => x.Namespace, x => x.ExtensionObject);
}
private static Dictionary<string, object> GetXsltExtensionsImpl()
{
// fill a dictionary with the predefined extensions
var extensions = new Dictionary<string, object>(GetPredefinedXsltExtensions());
// Load the XSLT extensions configuration
var xsltExt = new XmlDocument();
xsltExt.Load(XsltExtensionsConfig);
// add all descendants of the XsltExtensions element
foreach (XmlNode xsltEx in xsltExt.SelectSingleNode("/XsltExtensions"))
{
if (xsltEx.NodeType == XmlNodeType.Element)
{
Debug.Assert(xsltEx.Attributes["assembly"] != null, "Extension attribute 'assembly' not specified.");
Debug.Assert(xsltEx.Attributes["type"] != null, "Extension attribute 'type' not specified.");
Debug.Assert(xsltEx.Attributes["alias"] != null, "Extension attribute 'alias' not specified.");
// load the extension assembly
string extensionFile =
IOHelper.MapPath(string.Format("{0}/{1}.dll", SystemDirectories.Bin,
xsltEx.Attributes["assembly"].Value));
Assembly extensionAssembly;
try
{
extensionAssembly = Assembly.LoadFrom(extensionFile);
}
catch (Exception ex)
{
throw new Exception(
String.Format(
"Could not load assembly {0} for XSLT extension {1}. Please check config/xsltExtensions.config.",
extensionFile, xsltEx.Attributes["alias"].Value), ex);
}
// load the extension type
Type extensionType = extensionAssembly.GetType(xsltEx.Attributes["type"].Value);
if (extensionType == null)
throw new Exception(
String.Format(
"Could not load type {0} ({1}) for XSLT extension {1}. Please check config/xsltExtensions.config.",
xsltEx.Attributes["type"].Value, extensionFile, xsltEx.Attributes["alias"].Value));
// create an instance and add it to the extensions list
extensions.Add(xsltEx.Attributes["alias"].Value, Activator.CreateInstance(extensionType));
}
}
//also get types marked with XsltExtension attribute
// zb-00042 #29949 : do not hide errors, refactor
var foundExtensions = Umbraco.Web.PluginManagerExtensions.ResolveXsltExtensions(PluginManager.Current);
foreach (var xsltType in foundExtensions)
{
var tpAttributes = xsltType.GetCustomAttributes(typeof(XsltExtensionAttribute), true);
foreach (XsltExtensionAttribute tpAttribute in tpAttributes)
{
var ns = !string.IsNullOrEmpty(tpAttribute.Namespace)
? tpAttribute.Namespace
: xsltType.FullName;
extensions.Add(ns, Activator.CreateInstance(xsltType));
}
}
return extensions;
}
/// <summary>
/// Gets the predefined XSLT extensions.
/// </summary>
/// <remarks>
/// This is a legacy list of EXSLT extensions.
/// The Umbraco library is not included, because its instance is page specific.
/// </remarks>
/// <returns>A dictionary of name/extension instance pairs.</returns>
public static Dictionary<string, object> GetPredefinedXsltExtensions()
{
if (_predefinedExtensions == null)
{
_predefinedExtensions = new Dictionary<string, object>();
// [LK] U4-86 Move EXSLT references from being predefined in core to xsltExtensions.config
//// add predefined EXSLT extensions
//m_PredefinedExtensions.Add("Exslt.ExsltCommon", new ExsltCommon());
//m_PredefinedExtensions.Add("Exslt.ExsltDatesAndTimes", new ExsltDatesAndTimes());
//m_PredefinedExtensions.Add("Exslt.ExsltMath", new ExsltMath());
//m_PredefinedExtensions.Add("Exslt.ExsltRegularExpressions", new ExsltRegularExpressions());
//m_PredefinedExtensions.Add("Exslt.ExsltStrings", new ExsltStrings());
//m_PredefinedExtensions.Add("Exslt.ExsltSets", new ExsltSets());
}
return _predefinedExtensions;
}
/// <summary>
/// Returns an XSLT argument list with all XSLT extensions added,
/// both predefined and configured ones.

1
src/Umbraco.Web/umbraco.presentation/umbraco/xslt/eXslt/ExsltCommon.cs
View File

@@ -9,6 +9,7 @@ namespace umbraco.presentation.xslt.Exslt
/// <summary>
/// This class implements the EXSLT functions in the http://exslt.org/common namespace.
/// </summary>
[Umbraco.Core.Macros.XsltExtension("Exslt.ExsltCommon")]
public class ExsltCommon
{

1
src/Umbraco.Web/umbraco.presentation/umbraco/xslt/eXslt/ExsltDatesAndTimes.cs
View File

@@ -8,6 +8,7 @@ namespace umbraco.presentation.xslt.Exslt
/// <summary>
/// This class implements the EXSLT functions in the http://exslt.org/dates-and-times namespace.
/// </summary>
[Umbraco.Core.Macros.XsltExtension("Exslt.ExsltDatesAndTimes")]
public class ExsltDatesAndTimes
{

1
src/Umbraco.Web/umbraco.presentation/umbraco/xslt/eXslt/ExsltMath.cs
View File

@@ -7,6 +7,7 @@ namespace umbraco.presentation.xslt.Exslt
/// <summary>
/// This class implements the EXSLT functions in the http://exslt.org/math namespace.
/// </summary>
[Umbraco.Core.Macros.XsltExtension("Exslt.ExsltMath")]
public class ExsltMath {
/// <summary>
/// Implements the following function

1
src/Umbraco.Web/umbraco.presentation/umbraco/xslt/eXslt/ExsltRegularExpressions.cs
View File

@@ -8,6 +8,7 @@ namespace umbraco.presentation.xslt.Exslt
/// <summary>
/// This class implements the EXSLT functions in the http://exslt.org/regular-expressions namespace.
/// </summary>
[Umbraco.Core.Macros.XsltExtension("Exslt.ExsltRegularExpressions")]
public class ExsltRegularExpressions {
/// <summary>

1
src/Umbraco.Web/umbraco.presentation/umbraco/xslt/eXslt/ExsltSets.cs
View File

@@ -9,6 +9,7 @@ namespace umbraco.presentation.xslt.Exslt
/// <summary>
/// This class implements the EXSLT functions in the http://exslt.org/sets namespace.
/// </summary>
[Umbraco.Core.Macros.XsltExtension("Exslt.ExsltSets")]
public class ExsltSets {
/// <summary>

1
src/Umbraco.Web/umbraco.presentation/umbraco/xslt/eXslt/ExsltStrings.cs
View File

@@ -9,6 +9,7 @@ namespace umbraco.presentation.xslt.Exslt
/// <summary>
/// Implements the functions in the http://exslt.org/strings namespace
/// </summary>
[Umbraco.Core.Macros.XsltExtension("Exslt.ExsltStrings")]
public class ExsltStrings {
/// <summary>
/// Implements the following function

2
src/UmbracoExamine/XsltExtensions.cs
View File

@@ -8,6 +8,7 @@ using Examine.LuceneEngine.Providers;
using Examine.LuceneEngine.SearchCriteria;
using Examine.SearchCriteria;
using Examine.Providers;
using Umbraco.Core.Macros;
using UmbracoExamine.DataServices;
namespace UmbracoExamine
@@ -18,6 +19,7 @@ namespace UmbracoExamine
/// <remarks>
/// XSLT extensions will ONLY work for provider that have a base class of BaseUmbracoIndexer
/// </remarks>
[XsltExtension("Examine")]
public class XsltExtensions
{
///<summary>

5
src/umbraco.businesslogic/IO/SystemFiles.cs
View File

@@ -38,11 +38,6 @@ namespace umbraco.IO
get { return Umbraco.Core.IO.SystemFiles.DashboardConfig; }
}
public static string XsltextensionsConfig
{
get { return Umbraco.Core.IO.SystemFiles.XsltextensionsConfig; }
}
public static string SkinningXml
{
get { return Umbraco.Core.IO.SystemFiles.SkinningXml; }

102
src/umbraco.cms/businesslogic/Packager/PackageActions/addXsltExtension.cs
View File

@@ -1,102 +0,0 @@
using System;
using System.Xml;
using umbraco.IO;
namespace umbraco.cms.businesslogic.packager.standardPackageActions
{
public class addXsltExtension : umbraco.interfaces.IPackageAction
{
#region IPackageAction Members
public bool Execute(string packageName, XmlNode xmlData)
{
string _assembly = xmlData.Attributes["assembly"].Value;
string _type = xmlData.Attributes["type"].Value;
string _alias = xmlData.Attributes["extensionAlias"].Value;
string xeConfig = SystemFiles.XsltextensionsConfig;
XmlDocument xdoc = new XmlDocument();
xdoc.PreserveWhitespace = true;
xdoc = xmlHelper.OpenAsXmlDocument(xeConfig);
XmlNode xn = xdoc.SelectSingleNode("//XsltExtensions");
if (xn != null)
{
bool insertExt = true;
if (xn.HasChildNodes)
{
foreach (XmlNode ext in xn.SelectNodes("//ext"))
{
if (ext.Attributes["alias"] != null && ext.Attributes["alias"].Value == _alias)
insertExt = false;
}
}
if (insertExt)
{
XmlNode newExt = umbraco.xmlHelper.addTextNode(xdoc, "ext", "");
newExt.Attributes.Append(umbraco.xmlHelper.addAttribute(xdoc, "assembly", _assembly.Replace("/bin/", "")));
newExt.Attributes.Append(umbraco.xmlHelper.addAttribute(xdoc, "type", _type));
newExt.Attributes.Append(umbraco.xmlHelper.addAttribute(xdoc, "alias", _alias));
xn.AppendChild(newExt);
xdoc.Save(IOHelper.MapPath(xeConfig));
return true;
}
}
return false;
}
public string Alias()
{
return "addXsltExtension";
}
public bool Undo(string packageName, XmlNode xmlData)
{
string _assembly = xmlData.Attributes["assembly"].Value;
string _type = xmlData.Attributes["type"].Value;
string _alias = xmlData.Attributes["extensionAlias"].Value;
string xeConfig = SystemFiles.XsltextensionsConfig;
XmlDocument xdoc = new XmlDocument();
xdoc.PreserveWhitespace = true;
xdoc = xmlHelper.OpenAsXmlDocument(xeConfig);
XmlNode xn = xdoc.SelectSingleNode("//XsltExtensions");
if (xn != null)
{
bool inserted = false;
if (xn.HasChildNodes)
{
foreach (XmlNode ext in xn.SelectNodes("//ext"))
{
if (ext.Attributes["alias"] != null && ext.Attributes["alias"].Value == _alias)
{
xn.RemoveChild(ext);
inserted = true;
}
}
}
if (inserted)
{
xdoc.Save(IOHelper.MapPath(xeConfig));
return true;
}
}
return false;
}
#endregion
public XmlNode SampleXml()
{
throw new NotImplementedException();
}
}
}

1
src/umbraco.cms/umbraco.cms.csproj
View File

@@ -251,7 +251,6 @@
<Compile Include="businesslogic\Packager\PackageActions\addDashboardSection.cs" />
<Compile Include="businesslogic\Packager\PackageActions\addProxyFeedHost.cs" />
<Compile Include="businesslogic\Packager\PackageActions\addStringToHtmlElement.cs" />
<Compile Include="businesslogic\Packager\PackageActions\addXsltExtension.cs" />
<Compile Include="businesslogic\Packager\PackageActions\allowDoctype.cs" />
<Compile Include="businesslogic\Packager\PackageActions\helper.cs" />
<Compile Include="businesslogic\Packager\PackageActions\moveRootDocument.cs" />