recls-ruby 2.13.0.1 → 2.13.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9e34f60c35aebc4cf9cb1e217c1e7cf3e0211abee3eddb8e6306daa601c36461
-  data.tar.gz: 888951b3419b4be2b453449a3f25b0ee725e78539449caf469c767bbc329fbd4
+  metadata.gz: 59eb42b0b882edabe96abf491f8a44947a84c8a2b721a16d0a1c785d4037397e
+  data.tar.gz: 51f05e185bf3e51a3c1badf5653431ee2d8e554f8d298a191b60f813b73022c3
 SHA512:
-  metadata.gz: d0756416a3dc1d95aae37a46e7d3db1bbea1347e7b0cc369088910662698361dcedf718da31d818b976fc78b342766dd155c969fab8593f90e6c644e8cc44d04
-  data.tar.gz: 85291a5a45c3b430f92fbed82f9033bc53d524fa67dde8fd40b6f85581032b625c0756e944ab57fb6a74c3b9f60e92264f05dd7cdd606f2e5ecd8f61b1cd774e
+  metadata.gz: b627bb5850d768f90001ff0192b0b1f8f2d09d04d9a3fd04ae96952297056b8728a68592205c39158647c6564ba450872623c14899c09f3c87dd99dda122ec9a
+  data.tar.gz: 74a224e1269bd4484a794a02f165b65138437b8790038cb3156f4147c4f66b08f7bfe29990228ae050be6bf89a504c487c79ccc8d2451fa496e6aa86f79cafa8

data/lib/recls/combine_paths_1.rb

@@ -4,11 +4,11 @@
 # Purpose:  Definition of Recls::compare_paths() for Ruby 1.x
 #
 # Created:  17th February 2014
-# Updated:  21st April 2024
+# Updated:  9th January 2025
 #
 # Author:   Matthew Wilson
 #
-# Copyright (c) 2019-2024, Matthew Wilson and Synesis Information Systems
+# Copyright (c) 2019-2025, Matthew Wilson and Synesis Information Systems
 # Copyright (c) 2014-2019, Matthew Wilson and Synesis Software
 # All rights reserved.
 #
@@ -45,7 +45,16 @@ require 'recls/ximpl/util'
 
 module Recls
 
-  # Combines paths
+  # Combines paths, optionally canonicalising them.
+  #
+  # Unlike `File::join()`, this method takes account of relative vs absolute
+  # elements in the sequence. Specifically, the rightmost non-relative
+  # element, if it exists, anchors the combination, such that any arguments
+  # to the left are ignored. Furthermore, any entries (of type
+  # `Recls::Entry`) in the sequence are given special treatment as follows:
+  # - a rightmost `#file?` or `#device?` is returned as the complete result;
+  # - a rightmost `#directory?` causes all prior elements to be ignored and
+  #   may be combined with subsequent elements;
   #
   # === Signature
   #
@@ -60,7 +69,22 @@ module Recls
 
     raise ArgumentError, 'must specify one or more path elements' if paths.empty?
 
-    ix_last_entry = paths.rindex { |path| ::Recls::Entry === path } and return paths[ix_last_entry]
+    ix_last_entry = paths.rindex { |path| ::Recls::Entry === path }
+
+    if ix_last_entry
+
+      fe = paths[ix_last_entry]
+
+      if fe.directory?
+
+        paths = paths[ix_last_entry..]
+      else
+
+        return fe
+      end
+    end
+
+    paths = paths.map { |path| path.to_str }
 
     return Recls::Ximpl.combine_paths paths, {}
   end

data/lib/recls/combine_paths_2plus.rb

@@ -4,11 +4,11 @@
 # Purpose:  Definition of Recls::compare_paths() for Ruby 2+
 #
 # Created:  17th February 2014
-# Updated:  21st April 2024
+# Updated:  9th January 2025
 #
 # Author:   Matthew Wilson
 #
-# Copyright (c) 2019-2024, Matthew Wilson and Synesis Information Systems
+# Copyright (c) 2019-2025, Matthew Wilson and Synesis Information Systems
 # Copyright (c) 2014-2019, Matthew Wilson and Synesis Software
 # All rights reserved.
 #
@@ -45,7 +45,16 @@ require 'recls/ximpl/util'
 
 module Recls
 
-  # Combines paths, optionally canonicalising them
+  # Combines paths, optionally canonicalising them.
+  #
+  # Unlike `File::join()`, this method takes account of relative vs absolute
+  # elements in the sequence. Specifically, the rightmost non-relative
+  # element, if it exists, anchors the combination, such that any arguments
+  # to the left are ignored. Furthermore, any entries (of type
+  # `Recls::Entry`) in the sequence are given special treatment as follows:
+  # - a rightmost `#file?` or `#device?` is returned as the complete result;
+  # - a rightmost `#directory?` causes all prior elements to be ignored and
+  #   may be combined with subsequent elements;
   #
   # === Signature
   #
@@ -66,7 +75,22 @@ module Recls
 
     raise ArgumentError, 'must specify one or more path elements' if paths.empty?
 
-    ix_last_entry = paths.rindex { |path| ::Recls::Entry === path } and return paths[ix_last_entry]
+    ix_last_entry = paths.rindex { |path| ::Recls::Entry === path }
+
+    if ix_last_entry
+
+      fe = paths[ix_last_entry]
+
+      if fe.directory?
+
+        paths = paths[ix_last_entry..]
+      else
+
+        return fe
+      end
+    end
+
+    paths = paths.map { |path| path.to_str }
 
     return Recls::Ximpl.combine_paths paths, options
   end

data/lib/recls/entry.rb

@@ -4,11 +4,11 @@
 # Purpose:  Defines the Recls::Entry class for the recls.Ruby library.
 #
 # Created:  24th July 2012
-# Updated:  21st April 2024
+# Updated:  9th January 2025
 #
 # Author:   Matthew Wilson
 #
-# Copyright (c) 2019-2024, Matthew Wilson and Synesis Information Systems
+# Copyright (c) 2019-2025, Matthew Wilson and Synesis Information Systems
 # Copyright (c) 2012-2019, Matthew Wilson and Synesis Software
 # All rights reserved.
 #
@@ -64,6 +64,7 @@ module Recls
     def initialize(path, file_stat, search_dir, flags)
 
       @file_stat    = file_stat
+      @flags        = flags
 
       @path         = Recls::Ximpl.absolute_path path
       @short_path   = nil
@@ -104,6 +105,8 @@ module Recls
         @short_path       = @file_stat.short_path
         @file_short_name  = Recls::Ximpl::Util.split_path(@short_path)[2]
       else
+
+        ;
       end
     end
 
@@ -237,9 +240,13 @@ module Recls
     # indicates whether the given entry represents a directory
     def directory?
 
-      return false if @file_stat.nil?
+      if @file_stat.nil?
 
-      @file_stat.directory?
+        (Recls::DETAILS_LATER | Recls::DIRECTORIES) == ((Recls::DETAILS_LATER | Recls::DIRECTORIES) & @flags)
+      else
+
+        @file_stat.directory?
+      end
     end
 
     alias_method :dir?, :directory?
@@ -247,9 +254,13 @@ module Recls
     # indicates whether the given entry represents a file
     def file?
 
-      return false if @file_stat.nil?
+      if @file_stat.nil?
+
+        (Recls::DETAILS_LATER | Recls::FILES) == ((Recls::DETAILS_LATER | Recls::FILES) & @flags)
+      else
 
-      @file_stat.file?
+        @file_stat.file?
+      end
     end
 
     # indicates whether the given entry represents a link

data/lib/recls/version.rb

@@ -4,7 +4,7 @@
 # Purpose:  Version for recls library
 #
 # Created:  14th February 2014
-# Updated:  21st April 2024
+# Updated:  24th April 2025
 #
 # Author:   Matthew Wilson
 #
@@ -43,7 +43,7 @@
 module Recls
 
   # Current version of the recls.Ruby library
-  VERSION           = '2.13.0.1'
+  VERSION           = '2.13.2'
 
   private
   # @!visibility private

data/lib/recls/ximpl/util.rb

@@ -780,7 +780,7 @@ module Recls
       raise ArgumentError, "`paths` must be an instance of `::Array`" if $DEBUG && !paths.is_a?(::Array)
       raise ArgumentError, "`paths` elements must be instances of `::String`" if $DEBUG && paths.any? { |s| !s.is_a?(::String) }
 
-      abs_ix  = 0
+      abs_ix = 0
 
       paths = paths.map { |path| '~' == path[0].to_s ? File.expand_path(path) : path }
 

data/lib/recls/ximpl/windows.rb

@@ -4,7 +4,7 @@
 # Purpose:  Windows-specific constructs for the recls library.
 #
 # Created:  19th February 2014
-# Updated:  21st April 2024
+# Updated:  2nd June 2024
 #
 # Author:   Matthew Wilson
 #
@@ -37,7 +37,14 @@
 # ######################################################################## #
 
 
-require 'Win32API'
+if RUBY_VERSION >= '2'
+
+  require 'fiddle'
+  require 'fiddle/import'
+else
+
+  require 'Win32API'
+end
 
 
 =begin
@@ -49,46 +56,136 @@ module Recls
   module Ximpl # :nodoc: all
 
     # @!visibility private
-    class FileStat < File::Stat # :nodoc:
+    module Kernel32
+
+      MAX_PATH              = 260
+      NULL                  = 0x00000000
+      OPEN_EXISTING         = 0x00000003
+    end # module Kernel32
+
+    if RUBY_VERSION >= '2'
+
+      module Kernel32
+        extend Fiddle::Importer
+
+        dlload 'kernel32.dll'
+
+        typealias 'BOOL', 'int'
+        typealias 'DWORD', 'unsigned long'
+        typealias 'HANDLE', 'void*'
+
+        BY_HANDLE_FILE_INFORMATION = struct [
+          'DWORD dwFileAttributes',
+          'DWORD ftCreationTime_0',
+          'DWORD ftCreationTime_1',
+          'DWORD ftLastAccessTime_0',
+          'DWORD ftLastAccessTime_1',
+          'DWORD ftLastWriteTime_0',
+          'DWORD ftLastWriteTime_1',
+          'DWORD dwVolumeSerialNumber',
+          'DWORD nFileSizeHigh',
+          'DWORD nFileSizeLow',
+          'DWORD nNumberOfLinks',
+          'DWORD nFileIndexHigh',
+          'DWORD nFileIndexLow',
+        ]
+
+        extern 'BOOL CloseHandle(HANDLE)'
+        extern 'HANDLE CreateFileA(const char*, DWORD, DWORD, void*, DWORD, DWORD, HANDLE)'
+        extern 'DWORD GetFileAttributesA(const char*)'
+        extern 'BOOL GetFileInformationByHandle(HANDLE, BY_HANDLE_FILE_INFORMATION*)'
+        extern 'DWORD GetShortPathNameA(const char*, char*, DWORD)'
+
+        INVALID_HANDLE_VALUE  = Fiddle::Pointer[-1]
+      end # module Kernel32
+
+      module Kernel32
+        def self.get_file_attributes(path)
+
+          attributes = GetFileAttributesA(path)
+
+          (0xFFFFFFFF == attributes) ? 0 : attributes
+        end
 
-      private
-      GetFileAttributes           = Win32API.new('kernel32', 'GetFileAttributes', [ 'P' ], 'I')
-      GetFileInformationByHandle  = Win32API.new('kernel32', 'GetFileInformationByHandle', [ 'L', 'P' ], 'I')
-      GetShortPathName            = Win32API.new('kernel32', 'GetShortPathName', [ 'P', 'P', 'L' ], 'L')
-      CreateFile                  = Win32API.new('kernel32', 'CreateFile', [ 'P', 'L', 'L', 'L', 'L', 'L', 'L' ], 'L')
-      CloseHandle                 = Win32API.new('kernel32', 'CloseHandle', [ 'L' ], 'L')
-      FILE_ATTRIBUTE_READONLY     = 0x00000001
-      FILE_ATTRIBUTE_HIDDEN       = 0x00000002
-      FILE_ATTRIBUTE_SYSTEM       = 0x00000004
-      FILE_ATTRIBUTE_DIRECTORY    = 0x00000010
-      FILE_ATTRIBUTE_ARCHIVE      = 0x00000020
-      FILE_ATTRIBUTE_DEVICE       = 0x00000040
-      FILE_ATTRIBUTE_NORMAL       = 0x00000080
-      FILE_ATTRIBUTE_TEMPORARY    = 0x00000100
-      FILE_ATTRIBUTE_COMPRESSED   = 0x00000800
-      FILE_ATTRIBUTE_ENCRYPTED    = 0x00004000
+        def self.get_short_path_name(path)
 
-      OPEN_EXISTING               = 0x00000003
-      FILE_FLAG_OVERLAPPED        = 0x40000000
-      NULL                        = 0x00000000
-      INVALID_HANDLE_VALUE        = 0xFFFFFFFF
+          buff = ' ' * MAX_PATH
 
-      MAX_PATH                    = 260
+          buf = Fiddle::Pointer[buff]
 
-      BHFI_pack_string            = 'LQQQLLLLLL'
+          n = GetShortPathNameA(path, buf, buf.size)
 
-      # @!visibility private
-      class ByHandleInformation # :nodoc:
+          (0 == n) ? nil : buff[0...n]
+        end
 
-        # @!visibility private
-        def initialize(path) # :nodoc:
+        def self.get_stat_shared(path)
+
+          volume_id   = 0
+          file_index  = 0
+          num_links   = 0
 
-          @volume_id  = 0
-          @file_index = 0
-          @num_links  = 0
+          hFile = CreateFileA(path, 0, 0, NULL, OPEN_EXISTING, 0, NULL)
+
+          if INVALID_HANDLE_VALUE != hFile
+
+            begin
+              bhfi = BY_HANDLE_FILE_INFORMATION.malloc
+
+              if GetFileInformationByHandle(hFile, bhfi)
+
+                volume_id   = bhfi.dwVolumeSerialNumber
+                file_index  = (bhfi.nFileIndexHigh << 32) | bhfi.nFileIndexLow
+                num_links   = bhfi.nNumberOfLinks
+              end
+            ensure
+
+              CloseHandle(hFile)
+            end
+          end
+
+          [ volume_id, file_index, num_links ]
+        end
+      end # module Kernel32
+    else
+
+      module Kernel32
+
+        CloseHandle                 = Win32API.new('kernel32', 'CloseHandle', [ 'L' ], 'L')
+        CreateFile                  = Win32API.new('kernel32', 'CreateFile', [ 'P', 'L', 'L', 'L', 'L', 'L', 'L' ], 'L')
+        GetFileAttributes           = Win32API.new('kernel32', 'GetFileAttributes', [ 'P' ], 'I')
+        GetFileInformationByHandle  = Win32API.new('kernel32', 'GetFileInformationByHandle', [ 'L', 'P' ], 'I')
+        GetShortPathName            = Win32API.new('kernel32', 'GetShortPathName', [ 'P', 'P', 'L' ], 'L')
+
+        INVALID_HANDLE_VALUE        = -1
+
+        BHFI_pack_string            = 'LQQQLLLLLL'
+      end # module Kernel32
+
+      module Kernel32
+        def self.get_file_attributes(path)
+
+          attributes = GetFileAttributes.call(path)
+
+          (0xFFFFFFFF == attributes) ? 0 : attributes
+        end
+
+        def self.get_short_path_name(path)
+
+          buff = ' ' * MAX_PATH
+
+          n = GetShortPathName.call(path, buff, buff.length)
+
+          (0 == n) ? nil : buff[0...n]
+        end
+
+        def self.get_stat_shared(path)
+
+          volume_id   = 0
+          file_index  = 0
+          num_links   = 0
+
+          hFile = CreateFile.call(path, 0, 0, NULL, OPEN_EXISTING, 0, NULL)
 
-          # for some reason not forcing this new string causes 'can't modify frozen string (TypeError)' (in Ruby 1.8.x)
-          hFile = CreateFile.call("#{path}", 0, 0, NULL, OPEN_EXISTING, 0, NULL);
           if INVALID_HANDLE_VALUE != hFile
 
             begin
@@ -99,15 +196,43 @@ module Recls
 
                 bhfi = bhfi.unpack(BHFI_pack_string)
 
-                @volume_id  = bhfi[4]
-                @file_index = (bhfi[8] << 32) | bhfi[9]
-                @num_links  = bhfi[7]
-              else
+                volume_id   = bhfi[4]
+                file_index  = (bhfi[8] << 32) | bhfi[9]
+                num_links   = bhfi[7]
               end
             ensure
+
               CloseHandle.call(hFile)
             end
           end
+
+          [ volume_id, file_index, num_links ]
+        end
+      end # module Kernel32
+    end
+
+    # @!visibility private
+    class FileStat < File::Stat # :nodoc:
+
+      private
+      FILE_ATTRIBUTE_READONLY     = 0x00000001
+      FILE_ATTRIBUTE_HIDDEN       = 0x00000002
+      FILE_ATTRIBUTE_SYSTEM       = 0x00000004
+      FILE_ATTRIBUTE_DIRECTORY    = 0x00000010
+      FILE_ATTRIBUTE_ARCHIVE      = 0x00000020
+      FILE_ATTRIBUTE_DEVICE       = 0x00000040
+      FILE_ATTRIBUTE_NORMAL       = 0x00000080
+      FILE_ATTRIBUTE_TEMPORARY    = 0x00000100
+      FILE_ATTRIBUTE_COMPRESSED   = 0x00000800
+      FILE_ATTRIBUTE_ENCRYPTED    = 0x00004000
+
+      # @!visibility private
+      class ByHandleInformation # :nodoc:
+
+        # @!visibility private
+        def initialize(path) # :nodoc:
+
+          @volume_id, @file_index, @num_links = Kernel32.get_stat_shared(path)
         end
 
         # @!visibility private
@@ -129,27 +254,18 @@ module Recls
       # @!visibility private
       def initialize(path) # :nodoc:
 
-        @path = path
-
-        # for some reason not forcing this new string causes 'can't modify frozen string (TypeError)'
-        attributes = GetFileAttributes.call("#{path}")
+        path = path.to_str
 
-        if 0xffffffff == attributes
+        @path = path
 
-          @attributes = 0
-        else
-
-          @attributes = attributes
-        end
+        @attributes = Kernel32.get_file_attributes(path)
 
         super(path)
 
         @by_handle_information = ByHandleInformation.new(path)
 
-        buff = ' ' * MAX_PATH
-        # not forcing this new string causes 'can't modify frozen string (TypeError)'
-        n = GetShortPathName.call("#{path}", buff, buff.length)
-        @short_path = (0 == n) ? nil : buff[0...n]
+        @short_path = Kernel32.get_short_path_name(path)
+
       end
 
       public
@@ -165,7 +281,7 @@ module Recls
       # @!visibility private
       def hidden? # :nodoc:
 
-        0 != (FILE_ATTRIBUTE_HIDDEN & @attributes)
+        has_attribute_? FILE_ATTRIBUTE_HIDDEN
       end
 
       # Windows-specific attributes
@@ -215,7 +331,7 @@ module Recls
 
       public
       # @!visibility private
-      def FileStat.stat(path) # :nodoc:
+      def self.stat(path) # :nodoc:
 
         Recls::Ximpl::FileStat.new(path)
       end

data/test/unit/tc_recls_entry.rb

@@ -19,7 +19,7 @@ class Test_Recls_entry < Test::Unit::TestCase
 
   def setup
 
-    @cwd = Dir.pwd
+    @cwd = Dir.pwd.freeze
   end
 
   def test_entry_does_not_mark_directory
@@ -51,5 +51,22 @@ class Test_Recls_entry < Test::Unit::TestCase
 
     assert_not_equal cwd.object_id, cwd2.object_id
   end
+
+  if Recls.windows?
+
+    def test_entry_file_short_name
+
+      cwd = Recls.stat @cwd
+
+      if cwd.file_short_name
+
+        if cwd.file_full_name != cwd.file_short_name
+
+          assert cwd.file_short_name =~ /^.{0,8}\..{0,3}$/, "'#{cwd.file_short_name}' does not match expected 8.3 form"
+          assert_equal cwd.file_short_name.upcase, cwd.file_short_name, "'#{cwd.file_short_name}' is not uppercase as expected"
+        end
+      end
+    end
+  end
 end
 

data/test/unit/tc_recls_util.rb

@@ -13,115 +13,6 @@ end
 require 'test/unit'
 
 
-class Test_combine_paths < Test::Unit::TestCase
-
-  def test_nil_nil
-
-    if RUBY_VERSION >= '2'
-
-      assert_raise_with_message(::ArgumentError, /must specify one or more path elements/) { Recls.combine_paths(nil, nil) }
-    else
-
-      assert_raise(::ArgumentError) { Recls.combine_paths(nil, nil) }
-    end
-  end
-
-  def test_origin_nil
-
-    strings = [
-
-      'abc',
-      'abc/def',
-      'abc/def/ghi.ext',
-    ]
-
-    strings.each do |s|
-
-      assert_equal s, Recls.combine_paths(nil, s)
-    end
-  end
-
-  def test_path_nil
-
-    strings = [
-
-      'abc',
-      'abc/def',
-      'abc/def/ghi.ext',
-    ]
-
-    strings.each do |s|
-
-      assert_equal s, Recls.combine_paths(s, nil)
-    end
-  end
-
-  def test_both_relative
-
-    assert_equal 'abc/def', Recls.combine_paths('abc', 'def')
-    assert_equal 'abc/def', Recls.combine_paths('abc/', 'def')
-    assert_equal 'abc/def/ghi', Recls.combine_paths('abc/def', 'ghi')
-    assert_equal 'abc/def/ghi', Recls.combine_paths('abc/def/', 'ghi')
-    assert_equal 'abc/def/ghi', Recls.combine_paths('abc', 'def/ghi')
-    assert_equal 'abc/def/ghi', Recls.combine_paths('abc/', 'def/ghi')
-    assert_equal 'abc/./def/ghi', Recls.combine_paths('abc/.', 'def/ghi')
-    assert_equal 'abc/./def/ghi', Recls.combine_paths('abc/./', 'def/ghi')
-
-    if RUBY_VERSION >= '2'
-
-      assert_equal 'abc/./def/ghi', Recls.combine_paths('abc/.', 'def/ghi', clean_path: false)
-      assert_equal 'abc/./def/ghi', Recls.combine_paths('abc/./', 'def/ghi', clean: false)
-      assert_equal 'abc/def/ghi', Recls.combine_paths('abc/.', 'def/ghi', clean_path: true)
-      assert_equal 'abc/def/ghi', Recls.combine_paths('abc/./', 'def/ghi', clean: true)
-      assert_equal 'abc/def/ghi', Recls.combine_paths('abc/./.', 'def/ghi', clean_path: true)
-      assert_equal 'abc/../def/ghi', Recls.combine_paths('abc/..', 'def/ghi')
-      assert_equal 'def/ghi', Recls.combine_paths('abc/..', 'def/ghi', clean_path: true)
-    end
-  end
-
-  def test_multiple_relative
-
-    if RUBY_VERSION >= '2'
-
-      assert_equal 'a/b/c/d/e/f/g', Recls.combine_paths('a', 'b', 'c', 'd/e/f/', 'g', clean: false)
-      assert_equal 'a/b/c/d/e/f/g', Recls.combine_paths('a', 'b', 'c', 'd/e/f/', 'g', clean: true)
-
-      assert_equal 'a/b/c/../d/e/f/g', Recls.combine_paths('a', 'b', 'c', '..', 'd/e/f/', 'g', clean: false)
-      assert_equal 'a/b/d/e/f/g', Recls.combine_paths('a', 'b', 'c', '..', 'd/e/f/', 'g/', clean: true)
-      assert_equal 'a/b/d/e/f/g/', Recls.combine_paths('a', 'b', 'c', '..', 'd/e/f/', 'g/', canonicalise: true)
-    end
-  end
-
-  def test_various_absolute_placings
-
-    assert_equal '/a/b/c/d/e/f/g', Recls.combine_paths('/', 'a', 'b', 'c', 'd/e', 'f/g')
-
-    assert_equal '/b/c/d/e/f/g', Recls.combine_paths('/', 'a', '/b', 'c', 'd/e', 'f/g')
-
-    assert_equal '/c/d/e/f/g', Recls.combine_paths('/', 'a', 'b', '/c', 'd/e', 'f/g')
-
-    assert_equal '/d/e/f/g', Recls.combine_paths('/', 'a', 'b', 'c', '/d/e', 'f/g')
-
-    assert_equal '/f/g', Recls.combine_paths('/', 'a', 'b', 'c', 'd/e', '/f/g')
-    assert_equal '/f/g/', Recls.combine_paths('/', 'a', 'b', 'c', 'd/e', '/f/g/')
-
-    if RUBY_VERSION >= '2'
-
-      assert_equal '/f/g', Recls.combine_paths('/', 'a', 'b', 'c', 'd/e', '/f/g/', clean: true)
-      assert_equal '/f/g/', Recls.combine_paths('/', 'a', 'b', 'c', 'd/e', '/f/g/', canonicalise: true)
-    end
-  end
-
-  def test_combining_with_entries
-
-    f_g = Recls.stat('/f/g', Recls::DETAILS_LATER)
-    b = Recls.stat('b', Recls::DETAILS_LATER)
-
-    assert_equal '/f/g', Recls.combine_paths('/', 'a', 'b', 'c', 'd/e', f_g)
-    assert_equal '/f/g', Recls.combine_paths('/', 'a', b, 'c', 'd/e', f_g)
-  end
-end
-
 class Test_canonicalise_path < Test::Unit::TestCase
 
   def test_nil

data/test/unit/util/tc_combine_paths.rb

@@ -0,0 +1,158 @@
+#! /usr/bin/env ruby
+
+$:.unshift File.join(File.dirname(__FILE__), '../../..', 'lib')
+
+require 'recls'
+
+require 'xqsr3/extensions/test/unit'
+require 'test/unit'
+
+require 'fileutils'
+
+
+class Test_combine_paths < Test::Unit::TestCase
+
+  def test_nil_nil
+
+    if RUBY_VERSION >= '2'
+
+      assert_raise_with_message(::ArgumentError, /must specify one or more path elements/) { Recls.combine_paths(nil, nil) }
+    else
+
+      assert_raise(::ArgumentError) { Recls.combine_paths(nil, nil) }
+    end
+  end
+
+  def test_origin_nil
+
+    strings = [
+
+      'abc',
+      'abc/def',
+      'abc/def/ghi.ext',
+    ]
+
+    strings.each do |s|
+
+      assert_equal s, Recls.combine_paths(nil, s)
+    end
+  end
+
+  def test_path_nil
+
+    strings = [
+
+      'abc',
+      'abc/def',
+      'abc/def/ghi.ext',
+    ]
+
+    strings.each do |s|
+
+      assert_equal s, Recls.combine_paths(s, nil)
+    end
+  end
+
+  def test_both_relative
+
+    assert_equal 'abc/def', Recls.combine_paths('abc', 'def')
+    assert_equal 'abc/def', Recls.combine_paths('abc/', 'def')
+    assert_equal 'abc/def/ghi', Recls.combine_paths('abc/def', 'ghi')
+    assert_equal 'abc/def/ghi', Recls.combine_paths('abc/def/', 'ghi')
+    assert_equal 'abc/def/ghi', Recls.combine_paths('abc', 'def/ghi')
+    assert_equal 'abc/def/ghi', Recls.combine_paths('abc/', 'def/ghi')
+    assert_equal 'abc/./def/ghi', Recls.combine_paths('abc/.', 'def/ghi')
+    assert_equal 'abc/./def/ghi', Recls.combine_paths('abc/./', 'def/ghi')
+
+    if RUBY_VERSION >= '2'
+
+      assert_equal 'abc/./def/ghi', Recls.combine_paths('abc/.', 'def/ghi', clean_path: false)
+      assert_equal 'abc/./def/ghi', Recls.combine_paths('abc/./', 'def/ghi', clean: false)
+      assert_equal 'abc/def/ghi', Recls.combine_paths('abc/.', 'def/ghi', clean_path: true)
+      assert_equal 'abc/def/ghi', Recls.combine_paths('abc/./', 'def/ghi', clean: true)
+      assert_equal 'abc/def/ghi', Recls.combine_paths('abc/./.', 'def/ghi', clean_path: true)
+      assert_equal 'abc/../def/ghi', Recls.combine_paths('abc/..', 'def/ghi')
+      assert_equal 'def/ghi', Recls.combine_paths('abc/..', 'def/ghi', clean_path: true)
+    end
+  end
+
+  def test_multiple_relative
+
+    if RUBY_VERSION >= '2'
+
+      assert_equal 'a/b/c/d/e/f/g', Recls.combine_paths('a', 'b', 'c', 'd/e/f/', 'g', clean: false)
+      assert_equal 'a/b/c/d/e/f/g', Recls.combine_paths('a', 'b', 'c', 'd/e/f/', 'g', clean: true)
+
+      assert_equal 'a/b/c/../d/e/f/g', Recls.combine_paths('a', 'b', 'c', '..', 'd/e/f/', 'g', clean: false)
+      assert_equal 'a/b/d/e/f/g', Recls.combine_paths('a', 'b', 'c', '..', 'd/e/f/', 'g/', clean: true)
+      assert_equal 'a/b/d/e/f/g/', Recls.combine_paths('a', 'b', 'c', '..', 'd/e/f/', 'g/', canonicalise: true)
+    end
+  end
+
+  def test_various_absolute_placings
+
+    assert_equal '/a/b/c/d/e/f/g', Recls.combine_paths('/', 'a', 'b', 'c', 'd/e', 'f/g')
+
+    assert_equal '/b/c/d/e/f/g', Recls.combine_paths('/', 'a', '/b', 'c', 'd/e', 'f/g')
+
+    assert_equal '/c/d/e/f/g', Recls.combine_paths('/', 'a', 'b', '/c', 'd/e', 'f/g')
+
+    assert_equal '/d/e/f/g', Recls.combine_paths('/', 'a', 'b', 'c', '/d/e', 'f/g')
+
+    assert_equal '/f/g', Recls.combine_paths('/', 'a', 'b', 'c', 'd/e', '/f/g')
+    assert_equal '/f/g/', Recls.combine_paths('/', 'a', 'b', 'c', 'd/e', '/f/g/')
+
+    if RUBY_VERSION >= '2'
+
+      assert_equal '/f/g', Recls.combine_paths('/', 'a', 'b', 'c', 'd/e', '/f/g/', clean: true)
+      assert_equal '/f/g/', Recls.combine_paths('/', 'a', 'b', 'c', 'd/e', '/f/g/', canonicalise: true)
+    end
+  end
+
+  def test_combining_with_entries
+
+    f_g = Recls.stat('/f/g', Recls::DETAILS_LATER | Recls::DIRECTORIES)
+    b = Recls.stat('b', Recls::DETAILS_LATER | Recls::DIRECTORIES)
+    root_b = Recls.stat('/b', Recls::DETAILS_LATER | Recls::DIRECTORIES)
+
+    assert_equal '/a/b/c/d/e/f/g', Recls.combine_paths('/', 'a', 'b', 'c', 'd/e', 'f/g')
+    assert_equal '/f/g', Recls.combine_paths('/', 'a', 'b', 'c', 'd/e', '/f/g')
+
+    assert_equal '/f/g', Recls.combine_paths('/', 'a', 'b', 'c', 'd/e', f_g)
+    assert_equal '/f/g', Recls.combine_paths('/', 'a', b, 'c', 'd/e', f_g)
+  end
+
+  def test_combining_with_entries_that_exist
+
+    fe_this_file = Recls.stat(__FILE__)
+    fe_this_dir = Recls.stat(File.dirname(__FILE__))
+
+    assert_true fe_this_file.file?
+    assert_false fe_this_file.directory?
+
+    assert_true fe_this_dir.directory?
+    assert_false fe_this_dir.file?
+
+    assert_equal fe_this_file.to_s, Recls.combine_paths(fe_this_file)
+    assert_equal fe_this_file.to_s, Recls.combine_paths(nil, fe_this_file)
+    assert_equal fe_this_file.to_s, Recls.combine_paths('abc', fe_this_file)
+    assert_equal fe_this_file.to_s, Recls.combine_paths(fe_this_file)
+    assert_equal fe_this_file.to_s, Recls.combine_paths(fe_this_file, nil)
+    assert_equal fe_this_file.to_s, Recls.combine_paths(fe_this_file, '')
+    assert_equal fe_this_file.to_s, Recls.combine_paths(fe_this_file, 'abc')
+    assert_equal fe_this_file.to_s, Recls.combine_paths('abc', fe_this_file, 'abc')
+
+    assert_equal fe_this_dir.to_s, Recls.combine_paths(fe_this_dir)
+    assert_equal fe_this_dir.to_s, Recls.combine_paths(nil, fe_this_dir)
+    assert_equal fe_this_dir.to_s, Recls.combine_paths('abc', fe_this_dir)
+    assert_equal fe_this_dir.to_s, Recls.combine_paths(fe_this_dir)
+    assert_equal fe_this_dir.to_s, Recls.combine_paths(fe_this_dir, nil)
+    assert_equal "#{fe_this_dir.to_s}/", Recls.combine_paths(fe_this_dir, '')
+    assert_equal "#{fe_this_dir.to_s}/abc", Recls.combine_paths(fe_this_dir, 'abc')
+    assert_equal "#{fe_this_dir.to_s}/abc", Recls.combine_paths('abc', fe_this_dir, 'abc')
+  end
+end
+
+
+# ############################## end of file ############################# #
+

data/test/unit/util/ts_all.rb

@@ -0,0 +1,22 @@
+#! /usr/bin/env ruby
+#
+# executes all other tests
+
+this_dir = File.expand_path(File.dirname(__FILE__))
+
+# all tc_*rb in current directory
+Dir[File.join(this_dir, 'tc_*rb')].each do |file|
+
+  $stderr.puts "requiring file '#{file}'" if $DEBUG
+
+  require file
+end
+
+# all ts_*rb in immediate sub-directories
+Dir[File.join(this_dir, '*', 'ts_*rb')].each do |file|
+
+  $stderr.puts "requiring file '#{file}'" if $DEBUG
+
+  require file
+end
+

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: recls-ruby
 version: !ruby/object:Gem::Version
-  version: 2.13.0.1
+  version: 2.13.2
 platform: ruby
 authors:
 - Matt Wilson
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2024-04-21 00:00:00.000000000 Z
+date: 2025-04-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: xqsr3
@@ -79,6 +79,8 @@ files:
 - test/unit/test_all_separately.cmd
 - test/unit/test_all_separately.sh
 - test/unit/ts_all.rb
+- test/unit/util/tc_combine_paths.rb
+- test/unit/util/ts_all.rb
 homepage: http://github.com/synesissoftware/recls.Ruby
 licenses:
 - BSD-3-Clause
@@ -98,7 +100,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.3.1
+rubygems_version: 3.1.6
 signing_key: 
 specification_version: 4
 summary: recls.Ruby