shorten unnecessarily long code

JonasIsensee · JonasIsensee · commit 848959d8d42b · 2025-11-16T18:31:56.000+01:00
diff --git a/src/groups.jl b/src/groups.jl
@@ -115,19 +115,7 @@ function Base.getindex(g::Group, name::AbstractString)
         return resolve_external_link(g.f, link)
     elseif isa(link, SoftLink)
         # Resolve soft link within the same file
-        # For relative paths, resolve from the current group
-        # For absolute paths, resolve from root
-        if startswith(link.path, '/')
-            # Absolute path - resolve from root
-            resolved_path = JLD2.normalize_hdf5_path(link.path)
-            # Attempt to resolve, let the file's getindex handle KeyError if target doesn't exist
-            # This approach provides better error messages automatically
-            return g.f[resolved_path]
-        else
-            # Relative path - resolve from current group
-            # resolve_relative_soft_link handles error cases appropriately
-            return resolve_relative_soft_link(g, link.path)
-        end
+        return resolve_soft_link(g, link.path)
     else
         throw(ArgumentError("Unknown link type: $(typeof(link))"))
     end
@@ -331,7 +319,7 @@ function parse_link_message(wmsg::HmWrap{HmLinkMessage})::AbstractLink
             # External link - two null-terminated strings in external_link blob
             blob = wmsg.external_link
             # Parse two null-terminated strings but skip the first byte which is reserved
-            strings = split_null_terminated_strings(blob, 2)
+            strings = split(String(blob), '\0', keepempty=false)
             if length(strings) != 2
                 throw(InvalidDataException("External link must contain exactly two null-terminated strings"))
             end
@@ -347,32 +335,6 @@ function parse_link_message(wmsg::HmWrap{HmLinkMessage})::AbstractLink
     end
 end
 
-"""
-    split_null_terminated_strings(blob::Vector{UInt8}) -> Vector{String}
-
-Split a byte blob containing null-terminated strings into separate string components.
-Used for parsing external link information.
-"""
-function split_null_terminated_strings(blob::Vector{UInt8}, start_idx=1)::Vector{String}
-    strings = String[]
-
-    for (i, byte) in enumerate(blob)
-        if byte == 0x00  # null terminator
-            if i > start_idx  # Don't create empty strings from consecutive nulls
-                push!(strings, String(blob[start_idx:i-1]))
-            end
-            start_idx = i + 1
-        end
-    end
-
-    # Handle case where last string is not null-terminated
-    if start_idx <= length(blob)
-        push!(strings, String(blob[start_idx:end]))
-    end
-
-    return strings
-end
-
 """
     group_path(g::Group) -> String
 
@@ -459,54 +421,6 @@ function find_group_path_simple(root::Group, target::Group, current_path::String
     return "/"
 end
 
-"""
-    resolve_relative_soft_link(g::Group, relative_path::String)
-
-Resolve a relative soft link path from the current group.
-
-# Supported Relative Paths
-- Simple relative paths without ".." (e.g., "temp", "subgroup/data")
-- Paths with ".." components have limited support when groups are loaded from disk
-
-# Algorithm
-For simple paths, navigates directly from the current group.
-For complex paths with "..", attempts to use group hierarchy but may fall back to error.
-"""
-function resolve_relative_soft_link(g::Group, relative_path::String)
-    # Parse the relative path components
-    path_components = split(relative_path, '/', keepempty=false)
-    current_group = g
-
-    # Check if this path contains ".." components
-    has_upward_navigation = any(c -> c == "..", path_components)
-
-    if has_upward_navigation
-        # Complex relative path with upward navigation
-        # This requires knowing the current group's path in the hierarchy
-        # For groups loaded from disk, this may not work perfectly
-        try
-            # Try to use the original path resolution approach
-            current_path = group_path(current_group)
-            resolved_path = resolve_soft_link_path(current_path, relative_path)
-            return current_group.f[resolved_path]
-        catch
-            # Fallback error message
-            throw(KeyError("Relative soft link with '..' components cannot be resolved for groups loaded from disk: $relative_path"))
-        end
-    else
-        # Simple relative path - navigate directly from current group
-        for component in path_components
-            if component != "." && !isempty(component)
-                # Navigate to child - this should work with normal getindex
-                current_group = current_group[component]
-            end
-            # Ignore "." and empty components
-        end
-
-        return current_group
-    end
-end
-
 function load_group(f::JLDFile, offset::RelOffset)
     # Messages
     links = OrderedDict{String,AbstractLink}()
diff --git a/src/path_resolution.jl b/src/path_resolution.jl
@@ -1,172 +1,11 @@
-# Path Resolution for JLD2 External Links
-# This module provides secure path resolution functionality for external file links
-
-"""
-    resolve_external_file_path(current_file_path::String, external_file_path::String) -> String
-
-Resolve an external file path relative to the current file's directory.
-
-# Arguments
-- `current_file_path`: Path to the current JLD2 file (used as reference for relative paths)
-- `external_file_path`: The external file path from the external link (may be relative or absolute)
-
-# Returns
-The resolved absolute path to the external file.
-
-# Path Processing
-- Normalizes path separators for cross-platform compatibility
-- Resolves relative paths relative to the current file's directory
-
-# Examples
-```julia
-# Relative external file path
-current = "/home/user/data/main.jld2"
-external = "./external_data.jld2"
-resolved = resolve_external_file_path(current, external)
-# Result: "/home/user/data/external_data.jld2"
-
-# Absolute external file path
-current = "/home/user/data/main.jld2"
-external = "/shared/datasets/public.jld2"
-resolved = resolve_external_file_path(current, external)
-# Result: "/shared/datasets/public.jld2"
-```
-"""
 function resolve_external_file_path(current_file_path::String, external_file_path::String)
-    # Handle absolute paths directly
-    if isabspath(external_file_path)
-        resolved_path = abspath(external_file_path)
-    else
-        # Resolve relative to current file's directory
-        current_dir = dirname(current_file_path)
-        resolved_path = abspath(joinpath(current_dir, external_file_path))
-    end
-
-    return resolved_path
-end
-
-
-"""
-    resolve_soft_link_path(group_path::String, soft_link_path::String) -> String
-
-Resolve a soft link path within the same HDF5 file.
-
-# Arguments
-- `group_path`: Current group's absolute path within the HDF5 file (e.g., "/data/measurements")
-- `soft_link_path`: The soft link target path (may be absolute or relative)
-
-# Returns
-The resolved absolute path within the HDF5 file.
-
-# Path Resolution Rules
-- Absolute paths (starting with '/') are used as-is
-- Relative paths are resolved relative to the containing group
-- Path separators are normalized to '/' for HDF5 compatibility
-- ".." components navigate up the group hierarchy
-
-# Examples
-```julia
-# Absolute soft link
-group_path = "/data/measurements"
-soft_path = "/results/analysis"
-resolved = resolve_soft_link_path(group_path, soft_path)
-# Result: "/results/analysis"
-
-# Relative soft link
-group_path = "/data/measurements"
-soft_path = "../calibration/offset"
-resolved = resolve_soft_link_path(group_path, soft_path)
-# Result: "/data/calibration/offset"
-```
-"""
-function resolve_soft_link_path(group_path::String, soft_link_path::String)
-    # Normalize path separators to HDF5 standard
-    normalized_soft_path = replace(soft_link_path, '\\' => '/')
-    normalized_group_path = replace(group_path, '\\' => '/')
-
-    # Handle absolute paths
-    if startswith(normalized_soft_path, '/')
-        return normalize_hdf5_path(normalized_soft_path)
-    end
-
-    # Handle relative paths
-    # Start from the group itself (not the parent directory)
-    base_path = normalized_group_path
-
-    # Handle empty base path (root group case)
-    if isempty(base_path) || base_path == "."
-        base_path = "/"
-    end
-
-    # Resolve relative path components
-    path_components = split(normalized_soft_path, '/')
-    current_components = split(base_path, '/', keepempty=false)
-
-    for component in path_components
-        if component == ".." && !isempty(current_components)
-            pop!(current_components)  # Go up one level
-        elseif component != "." && !isempty(component)
-            push!(current_components, component)  # Add component
-        end
-        # Ignore "." and empty components
-    end
-
-    # Reconstruct path
-    if isempty(current_components)
-        return "/"
-    else
-        return "/" * join(current_components, "/")
-    end
+    current_dir = dirname(current_file_path)
+    return abspath(joinpath(current_dir, external_file_path))
 end
 
-"""
-    normalize_hdf5_path(path::String) -> String
-
-Normalize an HDF5 path to standard format.
-
-# Rules
-- Ensures path starts with '/' (absolute)
-- Normalizes path separators to '/'
-- Removes redundant components like "//" or "/./"
-- Handles ".." components properly
-
-# Examples
-```julia
-normalize_hdf5_path("/data//measurements/./temp") # => "/data/measurements/temp"
-normalize_hdf5_path("data/measurements") # => "/data/measurements"
-```
-"""
-function normalize_hdf5_path(path::String)
-    # Normalize separators
-    normalized = replace(path, '\\' => '/')
-
-    # Ensure absolute path
-    if !startswith(normalized, '/')
-        normalized = "/" * normalized
-    end
-
-    # Split, process, and rejoin components
-    components = split(normalized, '/', keepempty=false)
-    result_components = String[]
-
-    for component in components
-        if component == ".."
-            # Go up one level (remove last component if any)
-            if !isempty(result_components)
-                pop!(result_components)
-            end
-        elseif component != "." && !isempty(component)
-            # Add non-empty, non-current-directory components
-            push!(result_components, component)
-        end
-        # Ignore "." and empty components
-    end
-
-    # Reconstruct path
-    if isempty(result_components)
-        return "/"
-    else
-        return "/" * join(result_components, "/")
+function resolve_soft_link(g::Group, path::String)
+    if !startswith(path, '/')
+        path = group_path(g) * "/" * path
     end
+    return path
 end
-
diff --git a/test/links.jl b/test/links.jl
@@ -137,35 +137,6 @@ end
     end
 end
 
-@testset "Link Message Parsing" begin
-    @testset "split_null_terminated_strings" begin
-        # Test basic splitting
-        blob1 = UInt8[0x48, 0x65, 0x6c, 0x6c, 0x6f, 0x00, 0x57, 0x6f, 0x72, 0x6c, 0x64, 0x00]  # "Hello\0World\0"
-        result1 = JLD2.split_null_terminated_strings(blob1)
-        @test result1 == ["Hello", "World"]
-
-        # Test with trailing string (no final null)
-        blob2 = UInt8[0x48, 0x65, 0x6c, 0x6c, 0x6f, 0x00, 0x57, 0x6f, 0x72, 0x6c, 0x64]  # "Hello\0World"
-        result2 = JLD2.split_null_terminated_strings(blob2)
-        @test result2 == ["Hello", "World"]
-
-        # Test empty string handling
-        blob3 = UInt8[0x00, 0x48, 0x69, 0x00]  # "\0Hi\0"
-        result3 = JLD2.split_null_terminated_strings(blob3)
-        @test result3 == ["Hi"]
-
-        # Test single string
-        blob4 = UInt8[0x48, 0x65, 0x6c, 0x6c, 0x6f]  # "Hello"
-        result4 = JLD2.split_null_terminated_strings(blob4)
-        @test result4 == ["Hello"]
-
-        # Test empty input
-        blob5 = UInt8[]
-        result5 = JLD2.split_null_terminated_strings(blob5)
-        @test result5 == String[]
-    end
-end
-
 @testset "Message Size Calculation" begin
     @testset "message_size_for_link" begin
         # For these tests, we mainly check that the function doesn't throw
@@ -698,26 +669,6 @@ end
         end
     end
 
-    @testset "Complex Path Resolution Scenarios" begin
-        # Test edge cases in path resolution with internal functions
-
-        # Test path normalization
-        @test JLD2.normalize_hdf5_path("/data//measurements/./temp") == "/data/measurements/temp"
-        @test JLD2.normalize_hdf5_path("data/measurements") == "/data/measurements"
-        @test JLD2.normalize_hdf5_path("/data/./measurements/../calibration") == "/data/calibration"
-
-        # Test absolute path resolution (these should work in resolve_soft_link_path)
-        @test JLD2.resolve_soft_link_path("/data/measurements", "/results/analysis") == "/results/analysis"
-        @test JLD2.resolve_soft_link_path("/", "/data/test") == "/data/test"
-
-        # Test simple relative path resolution (without ".." components)
-        @test JLD2.resolve_soft_link_path("/data/measurements", "temp") == "/data/measurements/temp"
-        @test JLD2.resolve_soft_link_path("/", "data/test") == "/data/test"
-
-        # Note: Complex relative path resolution with ".." components is tested elsewhere
-        # and has known limitations for groups loaded from disk
-    end
-
     @testset "Soft Link Display and Inspection" begin
         # Test that soft links display correctly in group listings
         mktempdir() do dir
