Fixed restsharp#520

Author: alexeyzimarev

RestSharp.Tests/RestSharp.Tests.csproj

@@ -109,4 +109,4 @@
       <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
     </None>
   </ItemGroup>
-</Project>
+</Project>

RestSharp.Tests/SampleClasses/ColorWithValue.cs

@@ -0,0 +1,9 @@
+namespace RestSharp.Tests.SampleClasses
+{
+    [Deserializers.DeserializeAs(Name = "Color")]
+    public class ColorWithValue
+    {
+        public string Name { get; set; }
+        public int Value { get; set; }
+    }
+}

RestSharp.Tests/XmlDeserializerTests.cs

@@ -8,62 +8,33 @@ namespace RestSharp.Authenticators.OAuth.Extensions
 {
     internal static class StringExtensions
     {
-        public static bool IsNullOrBlank(this string value)
-        {
-            return string.IsNullOrEmpty(value) ||
-                   !string.IsNullOrEmpty(value) && value.Trim() == string.Empty;
-        }
+        public static bool IsNullOrBlank(this string value) => string.IsNullOrEmpty(value) ||
+                                                               !string.IsNullOrEmpty(value) &&
+                                                               value.Trim() == string.Empty;
 
-        public static bool EqualsIgnoreCase(this string left, string right)
-        {
-            return string.Compare(left, right, StringComparison.OrdinalIgnoreCase) == 0;
-        }
+        public static bool EqualsIgnoreCase(this string left, string right) => 
+            string.Compare(left, right, StringComparison.OrdinalIgnoreCase) == 0;
 
-        public static bool EqualsAny(this string input, params string[] args)
-        {
-            return args.Aggregate(false, (current, arg) => current | input.Equals(arg));
-        }
+        public static bool EqualsAny(this string input, params string[] args) => 
+            args.Aggregate(false, (current, arg) => current | input.Equals(arg));
 
-        public static string FormatWith(this string format, params object[] args)
-        {
-            return string.Format(format, args);
-        }
+        public static string FormatWith(this string format, params object[] args) => 
+            string.Format(format, args);
 
-        public static string FormatWithInvariantCulture(this string format, params object[] args)
-        {
-            return string.Format(CultureInfo.InvariantCulture, format, args);
-        }
+        public static string FormatWithInvariantCulture(this string format, params object[] args) => 
+            string.Format(CultureInfo.InvariantCulture, format, args);
 
-        public static string Then(this string input, string value)
-        {
-            return string.Concat(input, value);
-        }
+        public static string Then(this string input, string value) => string.Concat(input, value);
 
-        public static string UrlEncode(this string value)
-        {
-            // [DC] This is more correct than HttpUtility; it escapes spaces as %20, not +
-            return Uri.EscapeDataString(value);
-        }
+        public static string UrlEncode(this string value) => Uri.EscapeDataString(value);
 
-        public static string UrlDecode(this string value)
-        {
-            return Uri.UnescapeDataString(value);
-        }
+        public static string UrlDecode(this string value) => Uri.UnescapeDataString(value);
 
-        public static Uri AsUri(this string value)
-        {
-            return new Uri(value);
-        }
+        public static Uri AsUri(this string value) => new Uri(value);
 
-        public static string ToBase64String(this byte[] input)
-        {
-            return Convert.ToBase64String(input);
-        }
+        public static string ToBase64String(this byte[] input) => Convert.ToBase64String(input);
 
-        public static byte[] GetBytes(this string input)
-        {
-            return Encoding.UTF8.GetBytes(input);
-        }
+        public static byte[] GetBytes(this string input) => Encoding.UTF8.GetBytes(input);
 
         public static string PercentEncode(this string s)
         {

RestSharp/Authenticators/OAuth/Extensions/StringExtensions.cs

@@ -424,17 +424,18 @@ protected virtual XElement GetElementByName(XElement root, XName name)
             if (root.Element(camelName) != null)
                 return root.Element(camelName);
 
-            if (name == "Value".AsNamespaced(name.NamespaceName) &&
-                (!root.HasAttributes || root.Attributes().All(x => x.Name != name)))
-                return root;
-
             // try looking for element that matches sanitized property name (Order by depth)
-            return root.Descendants()
+            var element = root.Descendants()
                        .OrderBy(d => d.Ancestors().Count())
                        .FirstOrDefault(d => d.Name.LocalName.RemoveUnderscoresAndDashes() == name.LocalName) ??
                    root.Descendants()
                        .OrderBy(d => d.Ancestors().Count())
                        .FirstOrDefault(d => d.Name.LocalName.RemoveUnderscoresAndDashes() == name.LocalName.ToLower());
+
+            return element == null && name == "Value".AsNamespaced(name.NamespaceName) &&
+                   (!root.HasAttributes || root.Attributes().All(x => x.Name != name))
+                ? root
+                : element;
         }
 
         protected virtual XAttribute GetAttributeByName(XElement root, XName name)

RestSharp/Deserializers/XmlDeserializer.cs

@@ -27,10 +27,7 @@ namespace RestSharp.Extensions
 {
     public static class StringExtensions
     {
-        public static string UrlDecode(this string input)
-        {
-            return HttpUtility.UrlDecode(input);
-        }
+        public static string UrlDecode(this string input) => HttpUtility.UrlDecode(input);
 
         /// <summary>
         ///     Uses Uri.EscapeDataString() based on recommendations on MSDN
@@ -61,46 +58,28 @@ public static string UrlEncode(this string input)
             return sb.ToString();
         }
 
-        public static string HtmlDecode(this string input)
-        {
-            return HttpUtility.HtmlDecode(input);
-        }
+        public static string HtmlDecode(this string input) => HttpUtility.HtmlDecode(input);
 
-        public static string HtmlEncode(this string input)
-        {
-            return HttpUtility.HtmlEncode(input);
-        }
+        public static string HtmlEncode(this string input) => HttpUtility.HtmlEncode(input);
 
-        public static string UrlEncode(this string input, Encoding encoding)
-        {
-            return HttpUtility.UrlEncode(input, encoding);
-        }
+        public static string UrlEncode(this string input, Encoding encoding) => HttpUtility.UrlEncode(input, encoding);
 
-        public static string HtmlAttributeEncode(this string input)
-        {
-            return HttpUtility.HtmlAttributeEncode(input);
-        }
+        public static string HtmlAttributeEncode(this string input) => HttpUtility.HtmlAttributeEncode(input);
 
         /// <summary>
         ///     Check that a string is not null or empty
         /// </summary>
         /// <param name="input">String to check</param>
         /// <returns>bool</returns>
-        public static bool HasValue(this string input)
-        {
-            return !string.IsNullOrEmpty(input);
-        }
+        public static bool HasValue(this string input) => !string.IsNullOrEmpty(input);
 
         /// <summary>
         ///     Remove underscores from a string
         /// </summary>
         /// <param name="input">String to process</param>
         /// <returns>string</returns>
-        public static string RemoveUnderscoresAndDashes(this string input)
-        {
-            return input.Replace("_", "")
-                .Replace("-", ""); // avoiding regex
-        }
+        public static string RemoveUnderscoresAndDashes(this string input) =>
+            input.Replace("_", "").Replace("-", "");
 
         /// <summary>
         ///     Parses most common JSON date formats
@@ -116,15 +95,11 @@ public static DateTime ParseJsonDate(this string input, CultureInfo culture)
             input = input.Replace("\r", "");
             input = input.RemoveSurroundingQuotes();
 
-            long unix;
-
-            if (long.TryParse(input, out unix))
+            if (long.TryParse(input, out var unix))
             {
                 var epoch = new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc);
 
-                if (unix > maxAllowedTimestamp)
-                    return epoch.AddMilliseconds(unix);
-                return epoch.AddSeconds(unix);
+                return unix > maxAllowedTimestamp ? epoch.AddMilliseconds(unix) : epoch.AddSeconds(unix);
             }
 
             if (input.Contains("/Date("))
@@ -180,24 +155,23 @@ private static DateTime ExtractDate(string input, string pattern, CultureInfo cu
             var dt = DateTime.MinValue;
             var regex = new Regex(pattern);
 
-            if (regex.IsMatch(input))
-            {
-                var matches = regex.Matches(input);
-                var match = matches[0];
-                var ms = Convert.ToInt64(match.Groups[1].Value);
-                var epoch = new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc);
+            if (!regex.IsMatch(input)) return dt;
 
-                dt = epoch.AddMilliseconds(ms);
+            var matches = regex.Matches(input);
+            var match = matches[0];
+            var ms = Convert.ToInt64(match.Groups[1].Value);
+            var epoch = new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc);
 
-                // adjust if time zone modifier present
-                if (match.Groups.Count <= 2 || string.IsNullOrEmpty(match.Groups[3].Value)) return dt;
+            dt = epoch.AddMilliseconds(ms);
 
-                var mod = DateTime.ParseExact(match.Groups[3].Value, "HHmm", culture);
+            // adjust if time zone modifier present
+            if (match.Groups.Count <= 2 || string.IsNullOrEmpty(match.Groups[3].Value)) return dt;
 
-                dt = match.Groups[2].Value == "+"
-                    ? dt.Add(mod.TimeOfDay)
-                    : dt.Subtract(mod.TimeOfDay);
-            }
+            var mod = DateTime.ParseExact(match.Groups[3].Value, "HHmm", culture);
+
+            dt = match.Groups[2].Value == "+"
+                ? dt.Add(mod.TimeOfDay)
+                : dt.Subtract(mod.TimeOfDay);
 
             return dt;
         }
@@ -208,21 +182,16 @@ private static DateTime ExtractDate(string input, string pattern, CultureInfo cu
         /// <param name="input">String to check</param>
         /// <param name="pattern">Pattern to match</param>
         /// <returns>bool</returns>
-        public static bool Matches(this string input, string pattern)
-        {
-            return Regex.IsMatch(input, pattern);
-        }
+        public static bool Matches(this string input, string pattern) => Regex.IsMatch(input, pattern);
 
         /// <summary>
         ///     Converts a string to pascal case
         /// </summary>
         /// <param name="lowercaseAndUnderscoredWord">String to convert</param>
         /// <param name="culture"></param>
         /// <returns>string</returns>
-        public static string ToPascalCase(this string lowercaseAndUnderscoredWord, CultureInfo culture)
-        {
-            return ToPascalCase(lowercaseAndUnderscoredWord, true, culture);
-        }
+        public static string ToPascalCase(this string lowercaseAndUnderscoredWord, CultureInfo culture) =>
+            ToPascalCase(lowercaseAndUnderscoredWord, true, culture);
 
         /// <summary>
         ///     Converts a string to pascal case with the option to remove underscores
@@ -270,88 +239,72 @@ public static string ToPascalCase(this string text, bool removeUnderscores, Cult
         /// <param name="lowercaseAndUnderscoredWord">String to convert</param>
         /// <param name="culture"></param>
         /// <returns>String</returns>
-        public static string ToCamelCase(this string lowercaseAndUnderscoredWord, CultureInfo culture)
-        {
-            return MakeInitialLowerCase(ToPascalCase(lowercaseAndUnderscoredWord, culture));
-        }
+        public static string ToCamelCase(this string lowercaseAndUnderscoredWord, CultureInfo culture) =>
+            MakeInitialLowerCase(ToPascalCase(lowercaseAndUnderscoredWord, culture));
 
         /// <summary>
         ///     Convert the first letter of a string to lower case
         /// </summary>
         /// <param name="word">String to convert</param>
         /// <returns>string</returns>
-        public static string MakeInitialLowerCase(this string word)
-        {
-            return string.Concat(word.Substring(0, 1).ToLower(), word.Substring(1));
-        }
+        public static string MakeInitialLowerCase(this string word) =>
+            string.Concat(word.Substring(0, 1).ToLower(), word.Substring(1));
 
         /// <summary>
         ///     Checks to see if a string is all uppper case
         /// </summary>
         /// <param name="inputString">String to check</param>
         /// <returns>bool</returns>
-        public static bool IsUpperCase(this string inputString)
-        {
-            return Regex.IsMatch(inputString, @"^[A-Z]+$");
-        }
+        public static bool IsUpperCase(this string inputString) => Regex.IsMatch(inputString, @"^[A-Z]+$");
 
         /// <summary>
         ///     Add underscores to a pascal-cased string
         /// </summary>
         /// <param name="pascalCasedWord">String to convert</param>
         /// <returns>string</returns>
-        public static string AddUnderscores(this string pascalCasedWord)
-        {
-            return Regex.Replace(
+        public static string AddUnderscores(this string pascalCasedWord) =>
+            Regex.Replace(
                 Regex.Replace(
                     Regex.Replace(pascalCasedWord, @"([A-Z]+)([A-Z][a-z])", "$1_$2"),
                     @"([a-z\d])([A-Z])",
                     "$1_$2"),
                 @"[-\s]",
                 "_");
-        }
 
         /// <summary>
         ///     Add dashes to a pascal-cased string
         /// </summary>
         /// <param name="pascalCasedWord">String to convert</param>
         /// <returns>string</returns>
-        public static string AddDashes(this string pascalCasedWord)
-        {
-            return Regex.Replace(
+        public static string AddDashes(this string pascalCasedWord) =>
+            Regex.Replace(
                 Regex.Replace(
                     Regex.Replace(pascalCasedWord, @"([A-Z]+)([A-Z][a-z])", "$1-$2"),
                     @"([a-z\d])([A-Z])",
                     "$1-$2"),
                 @"[\s]",
                 "-");
-        }
 
         /// <summary>
         ///     Add an undescore prefix to a pascasl-cased string
         /// </summary>
         /// <param name="pascalCasedWord"></param>
         /// <returns></returns>
-        public static string AddUnderscorePrefix(this string pascalCasedWord)
-        {
-            return string.Format("_{0}", pascalCasedWord);
-        }
+        public static string AddUnderscorePrefix(this string pascalCasedWord) => string.Format("_{0}", pascalCasedWord);
 
         /// <summary>
         ///     Add spaces to a pascal-cased string
         /// </summary>
         /// <param name="pascalCasedWord">String to convert</param>
         /// <returns>string</returns>
-        public static string AddSpaces(this string pascalCasedWord)
-        {
-            return Regex.Replace(
+        public static string AddSpaces(this string pascalCasedWord) =>
+            Regex.Replace(
                 Regex.Replace(
                     Regex.Replace(pascalCasedWord, @"([A-Z]+)([A-Z][a-z])", "$1 $2"),
                     @"([a-z\d])([A-Z])",
                     "$1 $2"),
                 @"[-\s]",
                 " ");
-        }
 
         /// <summary>
         ///     Return possible variants of a name for name matching.