From 4895b5a2a82cc986fa7281715eb7f1d1a0e347d1 Mon Sep 17 00:00:00 2001 From: Tim Geyssens Date: Mon, 4 Nov 2013 15:00:13 +0100 Subject: [PATCH] Fixes U4-3314 Doctype property alias doesn't auto generate camelcase but does pascalcase instead --- src/Umbraco.Core/StringExtensions.cs | 10 +++++++ .../Strings/DefaultShortStringHelper.cs | 28 +++++++++++++++++++ .../Strings/IShortStringHelper.cs | 21 ++++++++++++++ .../Strings/LegacyShortStringHelper.cs | 24 ++++++++++++++++ .../CoreStrings/MockShortStringHelper.cs | 10 +++++++ .../WebServices/CoreStringsController.cs | 6 ++-- 6 files changed, 96 insertions(+), 3 deletions(-) diff --git a/src/Umbraco.Core/StringExtensions.cs b/src/Umbraco.Core/StringExtensions.cs index dccda746af..65b6316ff9 100644 --- a/src/Umbraco.Core/StringExtensions.cs +++ b/src/Umbraco.Core/StringExtensions.cs @@ -952,6 +952,16 @@ namespace Umbraco.Core return ShortStringHelper.CleanStringForSafeAlias(alias); } + /// + /// Cleans a string to produce a string that can safely be used in an alias. + /// + /// The text to filter. + /// The safe alias. + public static string ToSafeCamelAlias(this string alias) + { + return ShortStringHelper.CleanStringForSafeCamelAlias(alias); + } + /// /// Cleans a string, in the context of a specified culture, to produce a string that can safely be used in an alias. /// diff --git a/src/Umbraco.Core/Strings/DefaultShortStringHelper.cs b/src/Umbraco.Core/Strings/DefaultShortStringHelper.cs index 547cf6090d..3194909329 100644 --- a/src/Umbraco.Core/Strings/DefaultShortStringHelper.cs +++ b/src/Umbraco.Core/Strings/DefaultShortStringHelper.cs @@ -248,6 +248,34 @@ function validateSafeAlias(id, value, immediate, callback) {{ return CleanString(text, CleanStringType.Ascii | CleanStringType.UmbracoCase | CleanStringType.Alias); } + /// + /// Cleans a string to produce a string that can safely be used in an alias. + /// + /// The text to filter. + /// The safe alias. + /// + /// The string will be cleaned in the context of the default culture. + /// Safe aliases are Ascii only. + /// + public virtual string CleanStringForSafeCamelAlias(string text) + { + return CleanString(text, CleanStringType.Ascii | CleanStringType.CamelCase | CleanStringType.Alias); + } + + /// + /// Cleans a string, in the context of a specified culture, to produce a string that can safely be used in an alias. + /// + /// The text to filter. + /// The culture. + /// The safe alias. + /// + /// Safe aliases are Ascii only. + /// + public virtual string CleanStringForSafeCamelAlias(string text, CultureInfo culture) + { + return CleanString(text, CleanStringType.Ascii | CleanStringType.CamelCase | CleanStringType.Alias, culture); + } + /// /// Cleans a string, in the context of a specified culture, to produce a string that can safely be used in an alias. /// diff --git a/src/Umbraco.Core/Strings/IShortStringHelper.cs b/src/Umbraco.Core/Strings/IShortStringHelper.cs index d415bdba4d..b1bab9c870 100644 --- a/src/Umbraco.Core/Strings/IShortStringHelper.cs +++ b/src/Umbraco.Core/Strings/IShortStringHelper.cs @@ -31,6 +31,19 @@ namespace Umbraco.Core.Strings /// string CleanStringForSafeAlias(string text); + + /// + /// Cleans a string to produce a string that can safely be used in an alias. + /// + /// The text to filter. + /// The safe alias. + /// + /// The string will be cleaned in the context of the IShortStringHelper default culture. + /// A safe alias is [a-z][a-zA-Z0-9_]* although legacy will also accept '-', and '_' at the beginning. + /// + string CleanStringForSafeCamelAlias(string text); + + /// /// Cleans a string, in the context of a specified culture, to produce a string that can safely be used in an alias. /// @@ -39,6 +52,14 @@ namespace Umbraco.Core.Strings /// The safe alias. string CleanStringForSafeAlias(string text, CultureInfo culture); + /// + /// Cleans a string, in the context of a specified culture, to produce a string that can safely be used in an alias. + /// + /// The text to filter. + /// The culture. + /// The safe alias. + string CleanStringForSafeCamelAlias(string text, CultureInfo culture); + /// /// Cleans a string to produce a string that can safely be used in an url segment. /// diff --git a/src/Umbraco.Core/Strings/LegacyShortStringHelper.cs b/src/Umbraco.Core/Strings/LegacyShortStringHelper.cs index 1c780703f4..70f869be54 100644 --- a/src/Umbraco.Core/Strings/LegacyShortStringHelper.cs +++ b/src/Umbraco.Core/Strings/LegacyShortStringHelper.cs @@ -138,6 +138,18 @@ function isValidAlias(alias) {{ return safeString.ToString(); } + /// + /// Cleans a string to produce a string that can safely be used in an alias. + /// + /// The text to filter. + /// The safe alias. + /// The string will be cleaned in the context of invariant culture. + public string CleanStringForSafeCamelAlias(string text) + { + var t = CleanStringForSafeAlias(text); + return Char.ToLowerInvariant(t[0]) + t.Substring(1); + } + /// /// Cleans a string, in the context of the invariant culture, to produce a string that can safely be used in an alias. /// @@ -150,6 +162,18 @@ function isValidAlias(alias) {{ return CleanStringForSafeAlias(text); } + /// + /// Cleans a string, in the context of the invariant culture, to produce a string that can safely be used in an alias. + /// + /// The text to filter. + /// The culture. + /// The safe alias. + /// Legacy does not support culture contexts. + public string CleanStringForSafeCamelAlias(string text, CultureInfo culture) + { + return CleanStringForSafeCamelAlias(text); + } + /// /// Cleans a string to produce a string that can safely be used in an url segment, in the context of the invariant culture. /// diff --git a/src/Umbraco.Tests/CoreStrings/MockShortStringHelper.cs b/src/Umbraco.Tests/CoreStrings/MockShortStringHelper.cs index 313093d8ff..1b2dd5a370 100644 --- a/src/Umbraco.Tests/CoreStrings/MockShortStringHelper.cs +++ b/src/Umbraco.Tests/CoreStrings/MockShortStringHelper.cs @@ -19,11 +19,21 @@ namespace Umbraco.Tests.CoreStrings return "SAFE-ALIAS::" + text; } + public string CleanStringForSafeCamelAlias(string text) + { + return "SAFE-ALIAS::" + text; + } + public string CleanStringForSafeAlias(string text, System.Globalization.CultureInfo culture) { return "SAFE-ALIAS-CULTURE::" + text; } + public string CleanStringForSafeCamelAlias(string text, System.Globalization.CultureInfo culture) + { + return "SAFE-ALIAS-CULTURE::" + text; + } + public string CleanStringForUrlSegment(string text) { return "URL-SEGMENT::" + text; diff --git a/src/Umbraco.Web/WebServices/CoreStringsController.cs b/src/Umbraco.Web/WebServices/CoreStringsController.cs index 2d8c8e71ce..2e5012e58c 100644 --- a/src/Umbraco.Web/WebServices/CoreStringsController.cs +++ b/src/Umbraco.Web/WebServices/CoreStringsController.cs @@ -18,11 +18,11 @@ namespace Umbraco.Web.WebServices public class CoreStringsController : UmbracoAuthorizedController { [HttpGet] - public JsonResult ToSafeAlias(string value) + public JsonResult ToSafeAlias(string value, bool camelCase = true) { return value == null - ? Json(new {error = "no value."}, JsonRequestBehavior.AllowGet) - : Json(new { alias = value.ToSafeAlias() }, JsonRequestBehavior.AllowGet); + ? Json(new {error = "no value."}, JsonRequestBehavior.AllowGet) + : Json(new { alias = camelCase ? value.ToSafeCamelAlias() : value.ToSafeAlias() }, JsonRequestBehavior.AllowGet); } [HttpGet]