fix: TryGetValue logic, JSON number types, and type conversion

v1.3.0 - Bug fixes and improvements

Fixed:
- TryGetValue now returns true for valid paths even when value is null
- Exception messages include full path for all error cases
- JSON array bounds checking throws proper exception

Added:
- Enhanced type conversion: Enum, Guid, Nullable<T> support
- Smarter JSON numbers: int/long for integers, double for floats
- XML documentation for ToExpando method
- 13 new test cases (108 total)

Author: birdnamoo

.gitignore

@@ -364,4 +364,5 @@ FodyWeavers.xsd
 /scripts/nuget-publish.ps1
 
 # Local
-.serena/
+.serena/
+CLAUDE.md

docs/CHANGELOG.md

@@ -5,6 +5,21 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [1.3.0] - 2025-01-20
+
+### Added
+
+- **Enhanced type conversion**: Support for `Enum`, `Guid`, and `Nullable<T>` types in `GetValue<T>()`
+- **Smarter JSON number handling**: JSON integers return `int`/`long`, floats return `double` (previously all returned `decimal`)
+- **XML documentation**: Added comprehensive XML docs to `ToExpando()` method
+- **New tests**: 13 additional test cases for bug fixes and improvements (108 total)
+
+### Fixed
+
+- **TryGetValue return logic**: Now correctly returns `true` for valid paths even when the value is `null`
+- **Exception message consistency**: All exceptions now include the full path for easier debugging
+- **JSON array bounds checking**: Proper exception thrown for out-of-bounds array access in JSON
+
 ## [1.2.0] - 2024-11-27
 
 ### Added

src/Directory.Build.props

@@ -7,7 +7,7 @@
     <ManagePackageVersionsCentrally>true</ManagePackageVersionsCentrally>
 
     <!-- Package Metadata -->
-    <Version>1.2.0</Version>
+    <Version>1.3.0</Version>
     <Authors>iyulab</Authors>
     <Company>Iyulab Corporation</Company>
     <Owners>iyulab</Owners>

src/ObjectPath.Tests/ObjectPathTests.cs

@@ -964,7 +964,7 @@ public void GetValue_ReturnsCorrectValue_ForJsonElement()
 
             // Assert
             Assert.Equal("John", name);
-            Assert.Equal(30m, age);
+            Assert.Equal(30, age);  // Changed from 30m to 30 (int) - JSON integers now return int
             Assert.Equal("New York", city);
             Assert.Equal("123 Main St", street);
             Assert.Equal("home", phoneType1);
@@ -1733,4 +1733,202 @@ private class CircularRefClass
     }
 
     #endregion
+
+    #region Phase 4: Bug Fixes and Improvements Tests
+
+    public class BugFixTests
+    {
+        [Fact]
+        public void TryGetValue_ReturnsTrue_WhenPathReturnsNullValue()
+        {
+            // Arrange - object with a null property value
+            var obj = new { Address = (string?)null };
+
+            // Act
+            var result = ObjectPath.TryGetValue(obj, "Address", out var value);
+
+            // Assert - should return true because path is valid, even though value is null
+            Assert.True(result);
+            Assert.Null(value);
+        }
+
+        [Fact]
+        public void TryGetValueT_ReturnsTrue_WhenPathReturnsNullValue()
+        {
+            // Arrange
+            var obj = new { Name = (string?)null };
+
+            // Act
+            var result = ObjectPath.TryGetValue<string>(obj, "Name", out var value);
+
+            // Assert
+            Assert.True(result);
+            Assert.Null(value);
+        }
+    }
+
+    public class JsonNumberTypeTests
+    {
+        [Fact]
+        public void GetValue_ReturnsInt_ForJsonInteger()
+        {
+            // Arrange
+            var json = """{"value": 42}""";
+            var doc = JsonDocument.Parse(json);
+
+            // Act
+            var value = ObjectPath.GetValue(doc.RootElement, "value");
+
+            // Assert
+            Assert.IsType<int>(value);
+            Assert.Equal(42, value);
+        }
+
+        [Fact]
+        public void GetValue_ReturnsLong_ForLargeJsonInteger()
+        {
+            // Arrange
+            var json = """{"value": 9223372036854775807}""";
+            var doc = JsonDocument.Parse(json);
+
+            // Act
+            var value = ObjectPath.GetValue(doc.RootElement, "value");
+
+            // Assert
+            Assert.IsType<long>(value);
+            Assert.Equal(9223372036854775807L, value);
+        }
+
+        [Fact]
+        public void GetValue_ReturnsDouble_ForJsonFloat()
+        {
+            // Arrange
+            var json = """{"value": 3.14159}""";
+            var doc = JsonDocument.Parse(json);
+
+            // Act
+            var value = ObjectPath.GetValue(doc.RootElement, "value");
+
+            // Assert
+            Assert.IsType<double>(value);
+            Assert.Equal(3.14159, value);
+        }
+    }
+
+    public class EnhancedTypeConversionTests
+    {
+        [Fact]
+        public void GetValueT_ConvertsStringToEnum()
+        {
+            // Arrange
+            var obj = new { Day = "Monday" };
+
+            // Act
+            var day = ObjectPath.GetValue<DayOfWeek>(obj, "Day");
+
+            // Assert
+            Assert.Equal(DayOfWeek.Monday, day);
+        }
+
+        [Fact]
+        public void GetValueT_ConvertsIntToEnum()
+        {
+            // Arrange
+            var obj = new { Day = 1 };  // Monday = 1
+
+            // Act
+            var day = ObjectPath.GetValue<DayOfWeek>(obj, "Day");
+
+            // Assert
+            Assert.Equal(DayOfWeek.Monday, day);
+        }
+
+        [Fact]
+        public void GetValueT_ConvertsStringToGuid()
+        {
+            // Arrange
+            var guidStr = "12345678-1234-1234-1234-123456789012";
+            var obj = new { Id = guidStr };
+
+            // Act
+            var guid = ObjectPath.GetValue<Guid>(obj, "Id");
+
+            // Assert
+            Assert.Equal(Guid.Parse(guidStr), guid);
+        }
+
+        [Fact]
+        public void GetValueT_ConvertsToNullableInt()
+        {
+            // Arrange
+            var obj = new { Value = 42 };
+
+            // Act
+            var value = ObjectPath.GetValue<int?>(obj, "Value");
+
+            // Assert
+            Assert.Equal(42, value);
+        }
+
+        [Fact]
+        public void TryGetValueT_ReturnsFalse_ForInvalidEnumString()
+        {
+            // Arrange
+            var obj = new { Day = "InvalidDay" };
+
+            // Act
+            var result = ObjectPath.TryGetValue<DayOfWeek>(obj, "Day", out var value);
+
+            // Assert
+            Assert.False(result);
+            Assert.Equal(default, value);
+        }
+
+        [Fact]
+        public void TryGetValueT_ReturnsFalse_ForInvalidGuidString()
+        {
+            // Arrange
+            var obj = new { Id = "not-a-guid" };
+
+            // Act
+            var result = ObjectPath.TryGetValue<Guid>(obj, "Id", out var value);
+
+            // Assert
+            Assert.False(result);
+            Assert.Equal(default, value);
+        }
+    }
+
+    public class ExceptionMessageTests
+    {
+        [Fact]
+        public void InvalidPath_ExceptionIncludesFullPath_ForJsonElement()
+        {
+            // Arrange
+            var json = """{"user": {"name": "John"}}""";
+            var doc = JsonDocument.Parse(json);
+
+            // Act & Assert
+            var ex = Assert.Throws<InvalidObjectPathException>(() =>
+                ObjectPath.GetValue(doc.RootElement, "user.email"));
+
+            Assert.Contains("user.email", ex.Message);
+        }
+
+        [Fact]
+        public void InvalidArrayIndex_ExceptionIncludesFullPath_ForJsonElement()
+        {
+            // Arrange
+            var json = """{"items": [1, 2, 3]}""";
+            var doc = JsonDocument.Parse(json);
+
+            // Act & Assert
+            var ex = Assert.Throws<InvalidObjectPathException>(() =>
+                ObjectPath.GetValue(doc.RootElement, "items[10]"));
+
+            Assert.Contains("items[10]", ex.Message);
+        }
+    }
+
+    #endregion
 }

src/ObjectPath/DictionaryExtensions.cs

@@ -4,6 +4,19 @@ namespace ObjectPathLibrary
 {
     public static class DictionaryExtensions
     {
+        /// <summary>
+        /// Converts a dictionary to an ExpandoObject, enabling dynamic property access.
+        /// Nested dictionaries are recursively converted to ExpandoObjects.
+        /// </summary>
+        /// <param name="dictionary">The source dictionary to convert.</param>
+        /// <returns>An ExpandoObject with properties matching the dictionary keys.</returns>
+        /// <example>
+        /// <code>
+        /// var dict = new Dictionary&lt;string, object?&gt; { ["Name"] = "John", ["Age"] = 30 };
+        /// dynamic expando = dict.ToExpando();
+        /// Console.WriteLine(expando.Name); // "John"
+        /// </code>
+        /// </example>
         public static dynamic ToExpando(this IDictionary<string, object?> dictionary)
         {
             var expando = new ExpandoObject();