refaxctored

Author: petesramek

.editorconfig

@@ -4,11 +4,6 @@ root = true
 # C# files
 [*.cs]
 
-# File header
-
-file_header_template = \nCopyright © Pete Sramek. All rights reserved.\nLicensed under the MIT License. See LICENSE file in the project root for full license information.\n
-dotnet_diagnostic.IDE0073.severity = warning
-
 #### Core EditorConfig Options ####
 
 # Indentation and spacing
@@ -139,6 +134,7 @@ csharp_prefer_simple_default_expression = true
 csharp_style_deconstructed_variable_declaration = true
 csharp_style_implicit_object_creation_when_type_is_apparent = true
 csharp_style_inlined_variable_declaration = true
+csharp_style_prefer_implicitly_typed_lambda_expression = true
 csharp_style_prefer_index_operator = true
 csharp_style_prefer_local_over_anonymous_function = false
 csharp_style_prefer_null_check_over_type_check = true
@@ -219,6 +215,10 @@ dotnet_naming_rule.types_should_be_pascal_case.severity = suggestion
 dotnet_naming_rule.types_should_be_pascal_case.symbols = types
 dotnet_naming_rule.types_should_be_pascal_case.style = pascal_case
 
+dotnet_naming_rule.private_or_internal_const_field_should_be_pascal_case.severity = suggestion
+dotnet_naming_rule.private_or_internal_const_field_should_be_pascal_case.symbols = private_or_internal_const_field
+dotnet_naming_rule.private_or_internal_const_field_should_be_pascal_case.style = pascal_case
+
 dotnet_naming_rule.private_or_internal_field_should_be_underscore_camel_case.severity = suggestion
 dotnet_naming_rule.private_or_internal_field_should_be_underscore_camel_case.symbols = private_or_internal_field
 dotnet_naming_rule.private_or_internal_field_should_be_underscore_camel_case.style = underscore_camel_case
@@ -241,10 +241,14 @@ dotnet_naming_symbols.types.applicable_kinds = class, struct, interface, enum
 dotnet_naming_symbols.types.applicable_accessibilities = public, internal, private, protected, protected_internal, private_protected
 dotnet_naming_symbols.types.required_modifiers = 
 
-dotnet_naming_symbols.non_field_members.applicable_kinds = property, event, method
+dotnet_naming_symbols.non_field_members.applicable_kinds = property, method, event
 dotnet_naming_symbols.non_field_members.applicable_accessibilities = public, internal, private, protected, protected_internal, private_protected
 dotnet_naming_symbols.non_field_members.required_modifiers = 
 
+dotnet_naming_symbols.private_or_internal_const_field.applicable_kinds = field
+dotnet_naming_symbols.private_or_internal_const_field.applicable_accessibilities = internal, private, protected_internal, private_protected
+dotnet_naming_symbols.private_or_internal_const_field.required_modifiers = const
+
 # Naming styles
 
 dotnet_naming_style.pascal_case.required_prefix = 

src/PolylineAlgorithm/Abstraction/AbstractPolylineDecoder.cs

@@ -11,6 +11,7 @@ namespace PolylineAlgorithm.Abstraction;
 using PolylineAlgorithm.Internal.Logging;
 using PolylineAlgorithm.Properties;
 using System;
+using System.Diagnostics.CodeAnalysis;
 
 /// <summary>
 /// Decodes encoded polyline strings into sequences of geographic coordinates.
@@ -134,7 +135,7 @@ static void ValidatePolyline(TPolyline polyline, ILogger<AbstractPolylineDecoder
     /// <returns>
     /// A <see cref="ReadOnlyMemory{T}"/> representing the encoded polyline data.
     /// </returns>
-    protected abstract ReadOnlyMemory<char> GetReadOnlyMemory(TPolyline? polyline);
+    protected abstract ReadOnlyMemory<char> GetReadOnlyMemory(TPolyline polyline);
 
     /// <summary>
     /// Creates a coordinate instance from the given latitude and longitude values.

src/PolylineAlgorithm/Abstraction/AbstractPolylineEncoder.cs

@@ -207,7 +207,7 @@ static void ValidateBuffer(ILogger<AbstractPolylineDecoder<TPolyline, TCoordinat
     /// The longitude value as a <see cref="double"/>.
     /// </returns>
 
-    protected abstract double GetLongitude(TCoordinate? current);
+    protected abstract double GetLongitude(TCoordinate current);
 
     /// <summary>
     /// Extracts the latitude value from the specified coordinate.
@@ -217,6 +217,6 @@ static void ValidateBuffer(ILogger<AbstractPolylineDecoder<TPolyline, TCoordinat
     /// The latitude value as a <see cref="double"/>.
     /// </returns>
 
-    protected abstract double GetLatitude(TCoordinate? current);
+    protected abstract double GetLatitude(TCoordinate current);
 }
 

src/PolylineAlgorithm/PolylineDecoder.cs

@@ -19,7 +19,6 @@ public PolylineDecoder(PolylineEncodingOptions options)
         : base(options) { }
 
     /// <inheritdoc />
-    
     protected override Coordinate CreateCoordinate(double latitude, double longitude) {
         return new(latitude, longitude);
     }

src/PolylineAlgorithm/PolylineEncoder.cs

@@ -19,19 +19,16 @@ public PolylineEncoder(PolylineEncodingOptions options)
         : base(options) { }
 
     /// <inheritdoc />
-    
     protected override double GetLatitude(Coordinate coordinate) {
         return coordinate.Latitude;
     }
 
     /// <inheritdoc />
-    
     protected override double GetLongitude(Coordinate coordinate) {
         return coordinate.Longitude;
     }
 
     /// <inheritdoc />
-    
     protected override Polyline CreatePolyline(ReadOnlyMemory<char> polyline) {
         return Polyline.FromMemory(polyline);
     }

src/PolylineAlgorithm/PolylineEncodingOptions.cs

@@ -15,15 +15,15 @@ namespace PolylineAlgorithm;
 /// <remarks>
 /// This class allows you to set options such as buffer size and logger factory for encoding operations.
 /// </remarks>
-[DebuggerDisplay("BufferSizeInBytes: {BufferSizeInBytes}, MaxBufferLength: {MaxBufferLength}, LoggerFactoryType: {LoggerFactory.GetType().Name}")]
+[DebuggerDisplay("MaxBufferSize: {MaxBufferSize}, MaxBufferLength: {MaxBufferLength}, LoggerFactoryType: {LoggerFactory.GetType().Name}")]
 public sealed class PolylineEncodingOptions {
     /// <summary>
     /// Gets the maximum buffer size for encoding operations.
     /// </summary>
     /// <remarks>
     /// The default buffer size is 64,000 bytes (64 KB). This can be adjusted based on the expected size of the polyline data.
     /// </remarks>
-    public int BufferSizeInBytes { get; internal set; } = 64_000;
+    public int MaxBufferSize { get; internal set; } = 64_000;
 
     /// <summary>
     /// Gets or sets the precision for encoding coordinates.
@@ -40,5 +40,5 @@ public sealed class PolylineEncodingOptions {
     /// <remarks>
     /// The maximum length is calculated based on the buffer size divided by the size of a character.
     /// </remarks>
-    internal int MaxBufferLength => BufferSizeInBytes / sizeof(char);
+    internal int MaxBufferLength => MaxBufferSize / sizeof(char);
 }

src/PolylineAlgorithm/PolylineEncodingOptionsBuilder.cs

@@ -36,23 +36,23 @@ public static PolylineEncodingOptionsBuilder Create() {
     /// </returns>
     public PolylineEncodingOptions Build() {
         return new PolylineEncodingOptions {
-            BufferSizeInBytes = _bufferSize,
+            MaxBufferSize = _bufferSize,
             LoggerFactory = _loggerFactory
         };
     }
 
     /// <summary>
     /// Sets the buffer size for encoding operations.
     /// </summary>
-    /// <param name="maxBufferSize">
+    /// <param name="bufferSize">
     /// The maximum buffer size. Must be greater than 11.
     /// </param>
     /// <returns>
     /// The current builder instance.
     /// </returns>
-    /// <exception cref="ArgumentOutOfRangeException">Thrown when <paramref name="maxBufferSize"/> is less than or equal to 11.</exception>
-    public PolylineEncodingOptionsBuilder WithBufferSize(int maxBufferSize) {
-        _bufferSize = maxBufferSize > 11 ? maxBufferSize : throw new ArgumentOutOfRangeException(nameof(maxBufferSize), string.Format(ExceptionMessageResource.BufferSizeMustBeGreaterThanMessageFormat, 11));
+    /// <exception cref="ArgumentOutOfRangeException">Thrown when <paramref name="bufferSize"/> is less than or equal to 11.</exception>
+    public PolylineEncodingOptionsBuilder WithMaxBufferSize(int bufferSize) {
+        _bufferSize = bufferSize > 11 ? bufferSize : throw new ArgumentOutOfRangeException(nameof(bufferSize), string.Format(ExceptionMessageResource.BufferSizeMustBeGreaterThanMessageFormat, 11));
 
         return this;
     }

tests/PolylineAlgorithm.Tests/AbstractPolylineEncoderTest.cs

@@ -88,7 +88,7 @@ public void Encode_EmptyCoordinates_Throws_ArgumentException() {
     [TestMethod]
     public void Encode_BufferTooSmall_Throws_InternalBufferOverflowException() {
         // Arrange
-        PolylineEncoder _encoder = new PolylineEncoder(new PolylineEncodingOptions { BufferSizeInBytes = 12 });
+        PolylineEncoder _encoder = new PolylineEncoder(new PolylineEncodingOptions { MaxBufferSize = 12 });
         IEnumerable<(double Latitude, double Longitude)> coordinates = RandomValueProvider.GetCoordinates(2);
 
         // Act

tests/PolylineAlgorithm.Tests/PolylineEncodingOptionsTest.cs

@@ -16,7 +16,7 @@ public void Constructor_Parameterless_Ok() {
         var options = new PolylineEncodingOptions();
 
         // Assert
-        Assert.AreEqual(64_000, options.BufferSizeInBytes);
+        Assert.AreEqual(64_000, options.MaxBufferSize);
         Assert.AreEqual(64_000 / sizeof(char), options.MaxBufferLength);
         Assert.IsInstanceOfType<NullLoggerFactory>(options.LoggerFactory);
     }
@@ -29,12 +29,12 @@ public void Constructor_ValidOptions_Ok() {
 
         // Act
         var options = new PolylineEncodingOptions() {
-            BufferSizeInBytes = bufferSize,
+            MaxBufferSize = bufferSize,
             LoggerFactory = loggerFactory
         };
 
         // Assert
-        Assert.AreEqual(bufferSize, options.BufferSizeInBytes);
+        Assert.AreEqual(bufferSize, options.MaxBufferSize);
         Assert.AreEqual(bufferSize / sizeof(char), options.MaxBufferLength);
         Assert.IsInstanceOfType<FakeLoggerFactory>(options.LoggerFactory);
     }

tests/PolylineAlgorithm.Tests/PolylineOptionsBuilderTest.cs

@@ -33,7 +33,7 @@ public void Build_Returns_Instance_With_Default_Values() {
 
         // Assert
         Assert.IsNotNull(options);
-        Assert.AreEqual(bufferSize, options.BufferSizeInBytes);
+        Assert.AreEqual(bufferSize, options.MaxBufferSize);
         Assert.AreEqual(bufferSize / sizeof(char), options.MaxBufferLength);
         Assert.AreEqual(loggerFactory, options.LoggerFactory);
     }
@@ -42,10 +42,10 @@ public void Build_Returns_Instance_With_Default_Values() {
     public void WithBufferSize_Small_BufferSize_Parameter_Returns_Throws_ArgumentOutOfRangeException() {
         // Arrange
         void WithSmallBufferSize() => PolylineEncodingOptionsBuilder.Create()
-            .WithBufferSize(11);
+            .WithMaxBufferSize(11);
 
         // Act
-        var exception = Assert.ThrowsException<ArgumentOutOfRangeException>(WithSmallBufferSize);
+        var exception = Assert.ThrowsExactly<ArgumentOutOfRangeException>(WithSmallBufferSize);
 
         // Assert
         Assert.IsNotNull(exception);
@@ -61,12 +61,12 @@ public void Build_Returns_Instance_With_Expected_Buffer_Size() {
 
         // Act
         var options = builder
-            .WithBufferSize(expected)
+            .WithMaxBufferSize(expected)
             .Build();
 
         // Assert
         Assert.IsNotNull(options);
-        Assert.AreEqual(expected, options.BufferSizeInBytes);
+        Assert.AreEqual(expected, options.MaxBufferSize);
         Assert.AreEqual(expected / sizeof(char), options.MaxBufferLength);
     }
 
@@ -93,7 +93,7 @@ void WithNullLoggerFactory() => PolylineEncodingOptionsBuilder.Create()
             .WithLoggerFactory(null!);
 
         // Act
-        var exception = Assert.ThrowsException<ArgumentNullException>(WithNullLoggerFactory);
+        var exception = Assert.ThrowsExactly<ArgumentNullException>(WithNullLoggerFactory);
 
         // Assert
         Assert.IsNotNull(exception);