From d12b00a79e7de89dfc2b94317f4e5ff4c66eb383 Mon Sep 17 00:00:00 2001 From: Alexey Zimarev Date: Wed, 12 Jun 2024 10:28:30 +0200 Subject: [PATCH] Added polyfills --- src/Directory.Build.props | 2 +- src/RestSharp/Polyfills/Index.cs | 129 ++++++++++++++++++ src/RestSharp/Polyfills/Range.cs | 81 +++++++++++ src/RestSharp/Request/RestRequest.cs | 27 ++-- src/RestSharp/RestSharp.csproj | 2 +- .../NewtonsoftJson/IntegratedTests.cs | 6 +- 6 files changed, 228 insertions(+), 19 deletions(-) create mode 100644 src/RestSharp/Polyfills/Index.cs create mode 100644 src/RestSharp/Polyfills/Range.cs diff --git a/src/Directory.Build.props b/src/Directory.Build.props index 2fa59dd14..70ef2495c 100644 --- a/src/Directory.Build.props +++ b/src/Directory.Build.props @@ -20,7 +20,7 @@ true - true + true diff --git a/src/RestSharp/Polyfills/Index.cs b/src/RestSharp/Polyfills/Index.cs new file mode 100644 index 000000000..6599a38fa --- /dev/null +++ b/src/RestSharp/Polyfills/Index.cs @@ -0,0 +1,129 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// See the LICENSE file in the project root for more information. + +#if !NET +using System.Runtime.CompilerServices; + +// ReSharper disable once CheckNamespace +namespace System; + +/// Represent a type can be used to index a collection either from the start or the end. +/// +/// Index is used by the C# compiler to support the new index syntax +/// +/// int[] someArray = new int[5] { 1, 2, 3, 4, 5 } ; +/// int lastElement = someArray[^1]; // lastElement = 5 +/// +/// +readonly struct Index : IEquatable { + readonly int _value; + + /// Construct an Index using a value and indicating if the index is from the start or from the end. + /// The index value. it has to be zero or positive number. + /// Indicating if the index is from the start or from the end. + /// + /// If the Index constructed from the end, index value 1 means pointing at the last element and index value 0 means pointing at beyond last element. + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public Index(int value, bool fromEnd = false) { + if (value < 0) { + throw new ArgumentOutOfRangeException(nameof(value), "value must be non-negative"); + } + + if (fromEnd) + _value = ~value; + else + _value = value; + } + + // The following private constructors mainly created for perf reason to avoid the checks + Index(int value) => _value = value; + + /// Create an Index pointing at first element. + public static Index Start => new(0); + + /// Create an Index pointing at beyond last element. + public static Index End => new(~0); + + /// Create an Index from the start at the position indicated by the value. + /// The index value from the start. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static Index FromStart(int value) { + if (value < 0) { + throw new ArgumentOutOfRangeException(nameof(value), "value must be non-negative"); + } + + return new Index(value); + } + + /// Create an Index from the end at the position indicated by the value. + /// The index value from the end. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static Index FromEnd(int value) { + if (value < 0) { + throw new ArgumentOutOfRangeException(nameof(value), "value must be non-negative"); + } + + return new Index(~value); + } + + /// Returns the index value. + public int Value { + get { + if (_value < 0) + return ~_value; + else + return _value; + } + } + + /// Indicates whether the index is from the start or the end. + public bool IsFromEnd => _value < 0; + + /// Calculate the offset from the start using the giving collection length. + /// The length of the collection that the Index will be used with. length has to be a positive value + /// + /// For performance reason, we don't validate the input length parameter and the returned offset value against negative values. + /// we don't validate either the returned offset is greater than the input length. + /// It is expected Index will be used with collections which always have non negative length/count. If the returned offset is negative and + /// then used to index a collection will get out of range exception which will be same affect as the validation. + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public int GetOffset(int length) { + var offset = _value; + + if (IsFromEnd) { + // offset = length - (~value) + // offset = length + (~(~value) + 1) + // offset = length + value + 1 + + offset += length + 1; + } + + return offset; + } + + /// Indicates whether the current Index object is equal to another object of the same type. + /// An object to compare with this object + public override bool Equals(object? value) => value is Index && _value == ((Index)value)._value; + + /// Indicates whether the current Index object is equal to another Index object. + /// An object to compare with this object + public bool Equals(Index other) => _value == other._value; + + /// Returns the hash code for this instance. + public override int GetHashCode() => _value; + + /// Converts integer number to an Index. + public static implicit operator Index(int value) => FromStart(value); + + /// Converts the value of the current Index object to its equivalent string representation. + public override string ToString() { + if (IsFromEnd) + return "^" + ((uint)Value).ToString(); + + return ((uint)Value).ToString(); + } +} +#endif \ No newline at end of file diff --git a/src/RestSharp/Polyfills/Range.cs b/src/RestSharp/Polyfills/Range.cs new file mode 100644 index 000000000..8b9682db6 --- /dev/null +++ b/src/RestSharp/Polyfills/Range.cs @@ -0,0 +1,81 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// See the LICENSE file in the project root for more information. + +#if !NET +using System.Runtime.CompilerServices; + +// ReSharper disable once CheckNamespace +namespace System; + +/// Represent a range has start and end indexes. +/// +/// Range is used by the C# compiler to support the range syntax. +/// +/// int[] someArray = new int[5] { 1, 2, 3, 4, 5 }; +/// int[] subArray1 = someArray[0..2]; // { 1, 2 } +/// int[] subArray2 = someArray[1..^0]; // { 2, 3, 4, 5 } +/// +/// +readonly struct Range : IEquatable { + /// Represent the inclusive start index of the Range. + public Index Start { get; } + + /// Represent the exclusive end index of the Range. + public Index End { get; } + + /// Construct a Range object using the start and end indexes. + /// Represent the inclusive start index of the range. + /// Represent the exclusive end index of the range. + public Range(Index start, Index end) { + Start = start; + End = end; + } + + /// Indicates whether the current Range object is equal to another object of the same type. + /// An object to compare with this object + public override bool Equals(object? value) + => value is Range r && + r.Start.Equals(Start) && + r.End.Equals(End); + + /// Indicates whether the current Range object is equal to another Range object. + /// An object to compare with this object + public bool Equals(Range other) => other.Start.Equals(Start) && other.End.Equals(End); + + /// Returns the hash code for this instance. + public override int GetHashCode() => Start.GetHashCode() * 31 + End.GetHashCode(); + + /// Converts the value of the current Range object to its equivalent string representation. + public override string ToString() => Start + ".." + End; + + /// Create a Range object starting from start index to the end of the collection. + public static Range StartAt(Index start) => new Range(start, Index.End); + + /// Create a Range object starting from first element in the collection to the end Index. + public static Range EndAt(Index end) => new Range(Index.Start, end); + + /// Create a Range object starting from first element to the end. + public static Range All => new Range(Index.Start, Index.End); + + /// Calculate the start offset and length of range object using a collection length. + /// The length of the collection that the range will be used with. length has to be a positive value. + /// + /// For performance reason, we don't validate the input length parameter against negative values. + /// It is expected Range will be used with collections which always have non negative length/count. + /// We validate the range is inside the length scope though. + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [CLSCompliant(false)] + public (int Offset, int Length) GetOffsetAndLength(int length) { + var start = Start.GetOffset(length); + var end = End.GetOffset(length); + + if ((uint)end > (uint)length || (uint)start > (uint)end) { + throw new ArgumentOutOfRangeException(nameof(length)); + } + + return (start, end - start); + } +} +#endif \ No newline at end of file diff --git a/src/RestSharp/Request/RestRequest.cs b/src/RestSharp/Request/RestRequest.cs index 90854652f..83c8447b7 100644 --- a/src/RestSharp/Request/RestRequest.cs +++ b/src/RestSharp/Request/RestRequest.cs @@ -12,13 +12,11 @@ // See the License for the specific language governing permissions and // limitations under the License. -using System.Net; using System.Net.Http.Headers; using RestSharp.Authenticators; using RestSharp.Extensions; using RestSharp.Interceptors; -// ReSharper disable ReplaceSubstringWithRangeIndexer // ReSharper disable UnusedAutoPropertyAccessor.Global namespace RestSharp; @@ -50,7 +48,7 @@ public RestRequest(string? resource, Method method = Method.Get) : this() { if (queryStringStart < 0 || Resource.IndexOf('=') <= queryStringStart) return; - var queryParams = ParseQuery(Resource.Substring(queryStringStart + 1)); + var queryParams = ParseQuery(Resource[(queryStringStart + 1)..]); Resource = Resource.Substring(0, queryStringStart); foreach (var param in queryParams) this.AddQueryParameter(param.Key, param.Value, false); @@ -64,7 +62,7 @@ public RestRequest(string? resource, Method method = Method.Get) : this() { var position = x.IndexOf('='); return position > 0 - ? new KeyValuePair(x.Substring(0, position), x.Substring(position + 1)) + ? new KeyValuePair(x[..position], x[(position + 1)..]) : new KeyValuePair(x, null); } ); @@ -84,12 +82,12 @@ public RestRequest(Uri resource, Method method = Method.Get) /// Always send a multipart/form-data request - even when no Files are present. /// public bool AlwaysMultipartFormData { get; set; } - + /// /// Always send a file as request content without multipart/form-data request - even when the request contains only one file parameter /// public bool AlwaysSingleFileAsContent { get; set; } - + /// /// When set to true, parameter values in a multipart form data requests will be enclosed in /// quotation marks. Default is false. Enable it if the remote endpoint requires parameters @@ -166,7 +164,7 @@ public RestRequest(Uri resource, Method method = Method.Get) /// Can be used to skip container or root elements that do not have corresponding deserialization targets. /// public string? RootElement { get; set; } - + /// /// HTTP version for the request. Default is Version11. /// @@ -217,10 +215,9 @@ public RestRequest(Uri resource, Method method = Method.Get) public Func? ResponseWriter { get => _responseWriter; set { - if (AdvancedResponseWriter != null) - throw new ArgumentException( - "AdvancedResponseWriter is not null. Only one response writer can be used." - ); + if (AdvancedResponseWriter != null) { + throw new ArgumentException("AdvancedResponseWriter is not null. Only one response writer can be used."); + } _responseWriter = value; } @@ -232,12 +229,14 @@ public RestRequest(Uri resource, Method method = Method.Get) public Func? AdvancedResponseWriter { get => _advancedResponseHandler; set { - if (ResponseWriter != null) throw new ArgumentException("ResponseWriter is not null. Only one response writer can be used."); + if (ResponseWriter != null) { + throw new ArgumentException("ResponseWriter is not null. Only one response writer can be used."); + } _advancedResponseHandler = value; } } - + /// /// Request-level interceptors. Will be combined with client-level interceptors if set. /// @@ -260,4 +259,4 @@ public RestRequest RemoveParameter(Parameter parameter) { } internal RestRequest AddFile(FileParameter file) => this.With(x => x._files.Add(file)); -} +} \ No newline at end of file diff --git a/src/RestSharp/RestSharp.csproj b/src/RestSharp/RestSharp.csproj index 7a512d80a..d01835924 100644 --- a/src/RestSharp/RestSharp.csproj +++ b/src/RestSharp/RestSharp.csproj @@ -9,7 +9,7 @@ - + diff --git a/test/RestSharp.Tests.Serializers.Json/NewtonsoftJson/IntegratedTests.cs b/test/RestSharp.Tests.Serializers.Json/NewtonsoftJson/IntegratedTests.cs index 9fcd45865..82925da7d 100644 --- a/test/RestSharp.Tests.Serializers.Json/NewtonsoftJson/IntegratedTests.cs +++ b/test/RestSharp.Tests.Serializers.Json/NewtonsoftJson/IntegratedTests.cs @@ -9,7 +9,7 @@ public sealed class IntegratedTests : IDisposable { readonly WireMockServer _server = WireMockServer.Start(); - [Fact] + [Fact, Obsolete("Obsolete")] public async Task Use_with_GetJsonAsync() { var data = Fixture.Create(); var serialized = JsonConvert.SerializeObject(data, JsonNetSerializer.DefaultSettings); @@ -20,7 +20,7 @@ public async Task Use_with_GetJsonAsync() { using var client = new RestClient(_server.Url!, configureSerialization: cfg => cfg.UseNewtonsoftJson()); - var response = await client.GetJsonAsync("/test"); + var response = await client.GetAsync("/test"); response.Should().BeEquivalentTo(data); } @@ -39,7 +39,7 @@ public async Task Use_with_GetJsonAsync_custom_settings() { using var client = new RestClient(_server.Url!, configureSerialization: cfg => cfg.UseNewtonsoftJson(settings)); - var response = await client.GetJsonAsync("/test"); + var response = await client.GetAsync("/test"); response.Should().BeEquivalentTo(data); }