is_abs -> is_abs_path and small doc changes

Author: wassup05

doc/specs/stdlib_system.md

@@ -981,7 +981,7 @@ A character string or `type(string_type)`.
 
 ---
 
-## `is_abs` - Checks if the path is absolute
+## `is_abs_path` - Checks if the path is absolute
 
 ### Status
 
@@ -996,7 +996,7 @@ a path starting with a drive letter (like `C:\Users\`)
 
 ### Syntax
 
-`res = ` [[stdlib_system(module):is_abs(interface)]]`(p)`
+`res = ` [[stdlib_system(module):is_abs_path(interface)]]`(p)`
 
 ### Class
 
@@ -1009,7 +1009,10 @@ Function
 
 ### Return values
 
-A `logical` indicating if the the path is absolute.
+The function returns a `logical` value:
+
+- `.true.` if the path is absolute.
+- `.false.` otherwise.
 
 ### Example
 
@@ -1047,7 +1050,7 @@ Function
 
 `res`: the absolutized version of the path, It is of type `character(:), allocatable`.
 
-`err`: It is an optional state return flag. On error if not requested, an `FS_ERROR` will trigger an error stop.
+`err`: it is an optional state return flag. On error if not requested, an `FS_ERROR` will trigger an error stop.
 
 ### Example
 

example/system/example_path_abs.f90

@@ -1,14 +1,14 @@
-! Illustrate the usage of `abs_path`, `is_abs`
+! Illustrate the usage of `abs_path`, `is_abs_path`
 program example_path_abs
-    use stdlib_system, only: abs_path, is_abs
+    use stdlib_system, only: abs_path, is_abs_path
     use stdlib_error, only: state_type
     implicit none
 
     character(*), parameter :: path = "path/to/check"
     character(:), allocatable :: absolute_path
     type(state_type) :: err
 
-    if (is_abs(path)) then
+    if (is_abs_path(path)) then
         print *, "Path is absolute!"
         ! terminate the program since path is already absolute
         stop

src/stdlib_system.F90

@@ -93,7 +93,7 @@ module stdlib_system
 public :: split_path
 public :: base_name
 public :: dir_name
-public :: is_abs
+public :: is_abs_path
 public :: abs_path
 
 !! version: experimental
@@ -783,26 +783,26 @@ module function dir_name_string(p) result(dir)
     end function dir_name_string
 end interface dir_name
 
-interface is_abs
+interface is_abs_path
     !! version: experimental
     !!
     !!### Summary
     !! This function checks if the path is absolute.
-    !! ([Specification](../page/specs/stdlib_system.html#is_abs))
+    !! ([Specification](../page/specs/stdlib_system.html#is_abs_path))
     !!
     !!### Description
     !! This function checks if the path is absolute (i.e not relative).
     !! - On POSIX systems this means the path starts with `/`.
     !! - On Windows systems this means the path is either an UNC path (like `\\host\path\share`) or
     !! a path starting with a drive letter (like `C:\Users\`)
-    module logical function is_abs_char(p)
+    module logical function is_abs_path_char(p)
         character(len=*), intent(in) :: p
-    end function is_abs_char
+    end function is_abs_path_char
 
-    module logical function is_abs_string(p)
+    module logical function is_abs_path_string(p)
         type(string_type), intent(in) :: p
-    end function is_abs_string
-end interface is_abs
+    end function is_abs_path_string
+end interface is_abs_path
 
 interface abs_path
     !! version: experimental

src/stdlib_system_path.f90

@@ -168,27 +168,27 @@ module function dir_name_string(p) result(dir)
         call split_path(p, dir, temp)
     end function dir_name_string
 
-    module logical function is_abs_char(p)
+    module logical function is_abs_path_char(p)
         character(len=*), intent(in) :: p
         character(len=1) :: sep
 
         sep = path_sep()
 
         if (sep == '/') then
             ! should start with '/'
-            is_abs_char = starts_with(p, sep)
+            is_abs_path_char = starts_with(p, sep)
         else
             ! should be either an UNC path like '\\server\host...'
             ! or should be starting with a drive letter like 'C:\Users\...'
-            is_abs_char = starts_with(p(2:), ':\') .or. starts_with(p, '\\')
+            is_abs_path_char = starts_with(p(2:), ':\') .or. starts_with(p, '\\')
         end if
-    end function is_abs_char
+    end function is_abs_path_char
 
-    module logical function is_abs_string(p)
+    module logical function is_abs_path_string(p)
         type(string_type), intent(in) :: p
 
-        is_abs_string = is_abs(char(p))
-    end function is_abs_string
+        is_abs_path_string = is_abs_path(char(p))
+    end function is_abs_path_string
 
     module function abs_path_char(p, err) result(abs_p)
         character(len=*), intent(in) :: p

test/system/test_path.f90

@@ -1,7 +1,7 @@
 module test_path
     use testdrive, only : new_unittest, unittest_type, error_type, check, skip_test
     use stdlib_system, only: join_path, operator(/), split_path, OS_TYPE, OS_WINDOWS, &
-        is_abs, abs_path, get_cwd
+        is_abs_path, abs_path, get_cwd
     use stdlib_error, only: state_type
     implicit none
 contains
@@ -14,7 +14,7 @@ subroutine collect_suite(testsuite)
             new_unittest('test_join_path', test_join_path), &
             new_unittest('test_join_path_operator', test_join_path_op), &
             new_unittest('test_split_path', test_split_path), &
-            new_unittest('test_is_abs', test_is_abs), &
+            new_unittest('test_is_abs_path', test_is_abs_path), &
             new_unittest('test_abs_path', test_abs_path) &
         ]
     end subroutine collect_suite
@@ -122,68 +122,68 @@ subroutine test_split_path(error)
         end if
     end subroutine test_split_path
 
-    subroutine test_is_abs(error)
+    subroutine test_is_abs_path(error)
         type(error_type), allocatable, intent(out) :: error
         character(:), allocatable :: p
         logical :: res
 
-        character(*), parameter :: msg = "is_abs: "
+        character(*), parameter :: msg = "is_abs_path: "
 
         if (OS_TYPE() == OS_WINDOWS) then
             p = '.'
-            res = is_abs(p)
+            res = is_abs_path(p)
             call check(error, .not. res, msg // p // " returns incorrect result")
             if (allocated(error)) return
 
             p = '..'
-            res = is_abs(p)
+            res = is_abs_path(p)
             call check(error, .not. res, msg // p // " returns incorrect result")
             if (allocated(error)) return
 
             p = 'C:\Windows'
-            res = is_abs(p)
+            res = is_abs_path(p)
             call check(error, res, msg // p // " returns incorrect result")
             if (allocated(error)) return
 
             ! a relative path pointing to the `Windows` folder
             ! in the current working directory in the drive C
             p = 'C:Windows'
-            res = is_abs(p)
+            res = is_abs_path(p)
             call check(error, .not. res, msg // p // " returns incorrect result")
             if (allocated(error)) return
 
             ! UNC paths
             p = '\\server_name\share_name\path'
-            res = is_abs(p)
+            res = is_abs_path(p)
             call check(error, res, msg // p // " returns incorrect result")
             if (allocated(error)) return
         else
             p = '.'
-            res = is_abs(p)
+            res = is_abs_path(p)
             call check(error, .not. res, msg // p // " returns incorrect result")
             if (allocated(error)) return
 
             p = '..'
-            res = is_abs(p)
+            res = is_abs_path(p)
             call check(error, .not. res, msg // p // " returns incorrect result")
             if (allocated(error)) return
 
             p = '/'
-            res = is_abs(p)
+            res = is_abs_path(p)
             call check(error, res, msg // p // " returns incorrect result")
             if (allocated(error)) return
 
             p = '/home/Alice'
-            res = is_abs(p)
+            res = is_abs_path(p)
             call check(error, res, msg // p // " returns incorrect result")
             if (allocated(error)) return
 
             p = './home/Alice'
-            res = is_abs(p)
+            res = is_abs_path(p)
             call check(error, .not. res, msg // p // " returns incorrect result")
             if (allocated(error)) return
         end if
-    end subroutine test_is_abs
+    end subroutine test_is_abs_path
 
     subroutine test_abs_path(error)
         type(error_type), allocatable, intent(out) :: error
@@ -201,7 +201,7 @@ subroutine test_abs_path(error)
         call check(error, err%ok(), "Could not get absolute path: " // err%print())
         if (allocated(error)) return
 
-        call check(error, is_abs(absolute_path), "absolute path created is not absolute")
+        call check(error, is_abs_path(absolute_path), "absolute path created is not absolute")
         if (allocated(error)) return
 
         call get_cwd(cwd, err)