sys-filesystem 1.4.3 → 1.4.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3b00e624e22bd699630d63b34f90be7758f82630a069f7db2a61e2139cb55888
-  data.tar.gz: 59add440f0203bade0430b2acd410e785b4ab0de416f272755a72db9276aa767
+  metadata.gz: 50a6340749a1de440a2a5dbc159b9b91c8eec2af1f781ba797ab13a938e7977f
+  data.tar.gz: 22caa97a8e08a651aed674f3baefb717f8667a39387956dffbd7a84f4694a226
 SHA512:
-  metadata.gz: eb24f3c965a15d090fd7fff5800cc4c1829a7ddc7f2cbc4e943bb7e57ae92749a6abfccfecd94e8522287e9700916fc22f57af164afa413459321fa9460ba9a3
-  data.tar.gz: d5d30e84e01f370ac62b77251f2c80c07964a99bebfa0cc30252237bc33830198d3a065c28a546c230327b1b951d45d95bc309f75276d17d7e1e8968ade216f2
+  metadata.gz: 604a600ddd040bfe5aed253ec8994d6a0314076b10bb0e322485d9fff5e5b964c4e900b35cb3e0785741b16ed4295dddcae8cbeb851efb5be0c8b0c5b3df7e6f
+  data.tar.gz: a7603a397ef5a8d5c20bf93460686d80ed53d49cb8abd193addd10d38d6e900cea985b283b712c5c6a61d34baa784fd394dd27a0cb303e68e8023ece7070e944

data/CHANGES.md

@@ -1,3 +1,7 @@
+## 1.4.4 - 12-Sep-2023
+* Yet another fix for 32-bit vs 64-bit linux, specifically for the Statvfs
+  struct. Thanks go to Josh Cooper for the spot and the patch.
+
 ## 1.4.3 - 20-Oct-2021
 * Another fix for 32-bit vs 64-bit Linux since it was realized we cannot always
   rely on the host architecture information. Handling for JRuby was improved

data/Rakefile

@@ -1,6 +1,7 @@
 require 'rake'
 require 'rake/clean'
 require 'rspec/core/rake_task'
+require 'rubocop/rake_task'
 
 CLEAN.include('**/*.gem', '**/*.rbc', '**/*.rbx', '**/*.lock')
 
@@ -25,6 +26,18 @@ task :example do
   sh "ruby -Ilib -Ilib/unix -Ilib/windows examples/example_stat.rb"
 end
 
+RuboCop::RakeTask.new
+
+namespace :rubocop do
+  RuboCop::RakeTask.new(:unix) do |task|
+    task.patterns = ['lib/sys/unix/sys/**/*.rb', 'spec/*unix*']
+  end
+
+  RuboCop::RakeTask.new(:windows) do |task|
+    task.patterns = ['lib/sys/windows/sys/**/*.rb', 'spec/*windows*']
+  end
+end
+
 desc "Run the test suite"
 RSpec::Core::RakeTask.new(:spec)
 

data/lib/sys/filesystem.rb

@@ -1,9 +1,4 @@
-module Sys
-  class Filesystem
-    # The version of the sys-filesystem library
-    VERSION = '1.4.3'.freeze
-  end
-end
+# frozen_string_literal: true
 
 require 'rbconfig'
 
@@ -13,10 +8,18 @@ else
   require_relative 'unix/sys/filesystem'
 end
 
-# Methods universal to all platforms
+# Methods and properties universal to all platforms
 
+# The Sys module serves as a namespace only.
 module Sys
+  # The Filesystem class serves as an abstract base class. Its methods
+  # return objects of other types. Do not instantiate.
   class Filesystem
+    # The version of the sys-filesystem library
+    VERSION = '1.4.4'
+
+    # Stat objects are returned by the Sys::Filesystem.stat method. Here
+    # we're adding universal methods.
     class Stat
       # Returns true if the filesystem is case sensitive for the current path.
       # Typically this will be any path on MS Windows or Macs using HFS.
@@ -26,14 +29,12 @@ module Sys
       # general rule, I do not recommend using this method for a root path.
       #
       def case_insensitive?
-        if path !~ /\w+/
-          if RbConfig::CONFIG['host_os'] =~ /darwin|mac|windows|mswin|mingw/i
-            true # Assumes HFS
-          else
-            false
-          end
-        else
+        if path =~ /\w+/
           File.identical?(path, path.swapcase)
+        elsif RbConfig::CONFIG['host_os'] =~ /darwin|mac|windows|mswin|mingw/i
+          true # Assumes HFS/APFS on Mac
+        else
+          false
         end
       end
 
@@ -46,8 +47,8 @@ module Sys
   end
 end
 
-# Some convenient methods for converting bytes to kb, mb, and gb.
-#
+# Reopen the Numeric class and add some convenient methods
+# for converting bytes to kb, mb, and gb.
 class Numeric
   # call-seq:
   #  <tt>num</tt>.to_kb

data/lib/sys/unix/sys/filesystem/constants.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Sys
   class Filesystem
     module Constants

data/lib/sys/unix/sys/filesystem/functions.rb

@@ -1,7 +1,10 @@
+# frozen_string_literal: true
+
 require 'ffi'
 
 module Sys
   class Filesystem
+    # A scoped module for internal FFI functions to be used by the main code.
     module Functions
       extend FFI::Library
 
@@ -9,18 +12,21 @@ module Sys
 
       def self.linux64?
         if RUBY_PLATFORM == 'java'
-          ENV_JAVA['sun.arch.data.model'].to_i == 64
+          RbConfig::CONFIG['host_os'] =~ /linux/i &&
+            ENV_JAVA['sun.arch.data.model'].to_i == 64
         else
           RbConfig::CONFIG['host_os'] =~ /linux/i &&
             (RbConfig::CONFIG['arch'] =~ /64/ || RbConfig::CONFIG['DEFS'] =~ /64/)
         end
       end
 
+      def self.solaris?
+        RbConfig::CONFIG['host_os'] =~ /sunos|solaris/i
+      end
+
       private_class_method :linux64?
 
-      if RbConfig::CONFIG['host_os'] =~ /sunos|solaris/i
-        attach_function(:statvfs, :statvfs64, %i[string pointer], :int)
-      elsif linux64?
+      if linux64? || solaris?
         attach_function(:statvfs, :statvfs64, %i[string pointer], :int)
       else
         attach_function(:statvfs, %i[string pointer], :int)

data/lib/sys/unix/sys/filesystem/structs.rb

@@ -1,11 +1,14 @@
+# frozen_string_literal: true
+
 require 'ffi'
 require 'rbconfig'
 
 module Sys
   class Filesystem
     module Structs
+      # The Statfs struct is a subclass of FFI::Struct that corresponds to a struct statfs.
       class Statfs < FFI::Struct
-
+        # Private method that will determine the layout of the struct on Linux.
         def self.linux64?
           if RUBY_PLATFORM == 'java'
             ENV_JAVA['sun.arch.data.model'].to_i == 64
@@ -20,92 +23,103 @@ module Sys
         # FreeBSD 12.0 MNAMELEN from 88 => 1024.
         MNAMELEN =
           if RbConfig::CONFIG['host_os'] =~ /freebsd(.*)/i
-            $1.to_f < 12.0 ? 88 : 1024
+            Regexp.last_match(1).to_f < 12.0 ? 88 : 1024
           else
             88
           end
 
-        if RbConfig::CONFIG['host_os'] =~ /bsd/i
-          layout(
-            :f_version, :uint32,
-            :f_type, :uint32,
-            :f_flags, :uint64,
-            :f_bsize, :uint64,
-            :f_iosize, :int64,
-            :f_blocks, :uint64,
-            :f_bfree, :uint64,
-            :f_bavail, :int64,
-            :f_files, :uint64,
-            :f_ffree, :uint64,
-            :f_syncwrites, :uint64,
-            :f_asyncwrites, :uint64,
-            :f_syncreads, :uint64,
-            :f_asyncreads, :uint64,
-            :f_spare, [:uint64, 10],
-            :f_namemax, :uint32,
-            :f_owner, :int32,
-            :f_fsid,  [:int32, 2],
-            :f_charspare, [:char, 80],
-            :f_fstypename, [:char, 16],
-            :f_mntfromname, [:char, MNAMELEN],
-            :f_mntonname, [:char, MNAMELEN]
-          )
-        elsif RbConfig::CONFIG['host_os'] =~ /linux/i
-          if linux64?
+        case RbConfig::CONFIG['host_os']
+          when /bsd/i
             layout(
-              :f_type, :ulong,
-              :f_bsize, :ulong,
+              :f_version, :uint32,
+              :f_type, :uint32,
+              :f_flags, :uint64,
+              :f_bsize, :uint64,
+              :f_iosize, :int64,
               :f_blocks, :uint64,
               :f_bfree, :uint64,
-              :f_bavail, :uint64,
+              :f_bavail, :int64,
               :f_files, :uint64,
               :f_ffree, :uint64,
-              :f_fsid, [:int, 2],
-              :f_namelen, :ulong,
-              :f_frsize, :ulong,
-              :f_flags, :ulong,
-              :f_spare, [:ulong, 4]
+              :f_syncwrites, :uint64,
+              :f_asyncwrites, :uint64,
+              :f_syncreads, :uint64,
+              :f_asyncreads, :uint64,
+              :f_spare, [:uint64, 10],
+              :f_namemax, :uint32,
+              :f_owner, :int32,
+              :f_fsid,  [:int32, 2],
+              :f_charspare, [:char, 80],
+              :f_fstypename, [:char, 16],
+              :f_mntfromname, [:char, MNAMELEN],
+              :f_mntonname, [:char, MNAMELEN]
             )
+          when /linux/i
+            if linux64?
+              layout(
+                :f_type, :ulong,
+                :f_bsize, :ulong,
+                :f_blocks, :uint64,
+                :f_bfree, :uint64,
+                :f_bavail, :uint64,
+                :f_files, :uint64,
+                :f_ffree, :uint64,
+                :f_fsid, [:int, 2],
+                :f_namelen, :ulong,
+                :f_frsize, :ulong,
+                :f_flags, :ulong,
+                :f_spare, [:ulong, 4]
+              )
+            else
+              layout(
+                :f_type, :ulong,
+                :f_bsize, :ulong,
+                :f_blocks, :uint32,
+                :f_bfree, :uint32,
+                :f_bavail, :uint32,
+                :f_files, :uint32,
+                :f_ffree, :uint32,
+                :f_fsid, [:int, 2],
+                :f_namelen, :ulong,
+                :f_frsize, :ulong,
+                :f_flags, :ulong,
+                :f_spare, [:ulong, 4]
+              )
+            end
           else
             layout(
-              :f_type, :ulong,
-              :f_bsize, :ulong,
-              :f_blocks, :uint32,
-              :f_bfree, :uint32,
-              :f_bavail, :uint32,
-              :f_files, :uint32,
-              :f_ffree, :uint32,
-              :f_fsid, [:int, 2],
-              :f_namelen, :ulong,
-              :f_frsize, :ulong,
-              :f_flags, :ulong,
-              :f_spare, [:ulong, 4]
+              :f_bsize, :uint32,
+              :f_iosize, :int32,
+              :f_blocks, :uint64,
+              :f_bfree, :uint64,
+              :f_bavail, :uint64,
+              :f_files, :uint64,
+              :f_ffree, :uint64,
+              :f_fsid, [:int32, 2],
+              :f_owner, :int32,
+              :f_type, :uint32,
+              :f_flags, :uint32,
+              :f_fssubtype, :uint32,
+              :f_fstypename, [:char, 16],
+              :f_mntonname, [:char, 1024],
+              :f_mntfromname, [:char, 1024],
+              :f_reserved, [:uint32, 8]
             )
-          end
-        else
-          layout(
-            :f_bsize, :uint32,
-            :f_iosize, :int32,
-            :f_blocks, :uint64,
-            :f_bfree, :uint64,
-            :f_bavail, :uint64,
-            :f_files, :uint64,
-            :f_ffree, :uint64,
-            :f_fsid, [:int32, 2],
-            :f_owner, :int32,
-            :f_type, :uint32,
-            :f_flags, :uint32,
-            :f_fssubtype, :uint32,
-            :f_fstypename, [:char, 16],
-            :f_mntonname, [:char, 1024],
-            :f_mntfromname, [:char, 1024],
-            :f_reserved, [:uint32, 8]
-          )
         end
       end
 
       # The Statvfs struct represents struct statvfs from sys/statvfs.h.
       class Statvfs < FFI::Struct
+        # Private method that will determine the layout of the struct on Linux.
+        def self.linux64?
+          if RUBY_PLATFORM == 'java'
+            ENV_JAVA['sun.arch.data.model'].to_i == 64
+          else
+            RbConfig::CONFIG['host_os'] =~ /linux/i &&
+              (RbConfig::CONFIG['arch'] =~ /64/ || RbConfig::CONFIG['DEFS'] =~ /64/)
+          end
+        end
+
         if RbConfig::CONFIG['host_os'] =~ /darwin|osx|mach/i
           layout(
             :f_bsize, :ulong,
@@ -151,7 +165,7 @@ module Sys
             :f_fstr, [:char, 32],
             :f_filler, [:ulong, 16]
           )
-        elsif RbConfig::CONFIG['host'] =~ /i686/i
+        elsif !linux64?
           layout(
             :f_bsize, :ulong,
             :f_frsize, :ulong,

data/lib/sys/unix/sys/filesystem.rb

@@ -224,7 +224,7 @@ module Sys
       fs = Statvfs.new
 
       if statvfs(path, fs) < 0
-        raise Error, 'statvfs() function failed: ' + strerror(FFI.errno)
+        raise Error, "statvfs() function failed: #{strerror(FFI.errno)}"
       end
 
       obj = Sys::Filesystem::Stat.new
@@ -275,7 +275,7 @@ module Sys
         num = getmntinfo(buf, 2)
 
         if num == 0
-          raise Error, 'getmntinfo() function failed: ' + strerror(FFI.errno)
+          raise Error, "getmntinfo() function failed: #{strerror(FFI.errno)}"
         end
 
         ptr = buf.get_pointer(0)
@@ -419,7 +419,7 @@ module Sys
     #
     def self.mount(source, target, fstype = 'ext2', flags = 0, data = nil)
       if mount_c(source, target, fstype, flags, data) != 0
-        raise Error, 'mount() function failed: ' + strerror(FFI.errno)
+        raise Error, "mount() function failed: #{strerror(FFI.errno)}"
       end
 
       self

data/lib/sys/windows/sys/filesystem/functions.rb

@@ -2,6 +2,7 @@ require 'ffi'
 
 module Sys
   class Filesystem
+    # Wrapper module for Windows related FFI functions.
     module Functions
       extend FFI::Library
       ffi_lib :kernel32

data/lib/sys/windows/sys/filesystem/helper.rb

@@ -1,6 +1,9 @@
+# Reopen core Ruby classes here and add some custom methods.
 class String
   # Convenience method for converting strings to UTF-16LE for wide character
   # functions that require it.
+  #--
+  # TODO: Use a refinement.
   def wincode
     (tr(File::SEPARATOR, File::ALT_SEPARATOR) + 0.chr).encode('UTF-16LE')
   end

data/lib/sys/windows/sys/filesystem.rb

@@ -9,7 +9,6 @@ require 'time'
 
 # The Sys module serves as a namespace only.
 module Sys
-
   # The Filesystem class encapsulates information about your filesystem.
   class Filesystem
     include Sys::Filesystem::Constants
@@ -20,6 +19,7 @@ module Sys
 
     private_class_method :new
 
+    # Mount objects are returned by the Sys::Filesystem.mounts method.
     class Mount
       # The name of the volume. This is the device mapping.
       attr_reader :name
@@ -50,6 +50,7 @@ module Sys
       alias freq frequency
     end
 
+    # Stat objects are returned by the Sys::Filesystem.stat method.
     class Stat
       # The path of the file system.
       attr_reader :path
@@ -160,6 +161,8 @@ module Sys
     #--
     # I couldn't really find a good reason to use the wide functions for this
     # method. If you have one, patches welcome.
+    #--
+    # rubocop:disable Metrics/BlockLength
     #
     def self.mounts
       # First call, get needed buffer size
@@ -196,14 +199,14 @@ module Sys
         filesystem_flags     = FFI::MemoryPointer.new(:ulong)
 
         bool = GetVolumeInformationA(
-           drive,
-           volume,
-           volume.size,
-           volume_serial_number,
-           max_component_length,
-           filesystem_flags,
-           fsname,
-           fsname.size
+          drive,
+          volume,
+          volume.size,
+          volume_serial_number,
+          max_component_length,
+          filesystem_flags,
+          fsname,
+          fsname.size
         )
 
         # Skip unmounted floppies or cd-roms, or inaccessible drives
@@ -237,6 +240,7 @@ module Sys
 
       mounts # Nil if the block form was used.
     end
+    # rubocop:enable Metrics/BlockLength
 
     # Returns the mount point for the given +file+. For MS Windows this
     # means the root of the path.
@@ -250,8 +254,6 @@ module Sys
 
       if PathStripToRootW(wfile)
         wfile.read_string(wfile.size).split("\000\000").first.tr(0.chr, '')
-      else
-        nil
       end
     end
 

data/lib/sys-filesystem.rb

@@ -1 +1,3 @@
+# frozen_string_literal: true
+
 require_relative 'sys/filesystem'

data/spec/spec_helper.rb

@@ -1,6 +1,10 @@
+# frozen_string_literal: true
+
 require 'rspec'
+require 'sys_filesystem_shared'
 
 RSpec.configure do |config|
+  config.include_context(Sys::Filesystem)
   config.filter_run_excluding(:windows) unless Gem.win_platform?
   config.filter_run_excluding(:unix) if Gem.win_platform?
 end

data/spec/sys_filesystem_shared.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require 'sys-filesystem'
+
+RSpec.shared_examples Sys::Filesystem do
+  example 'version number is set to the expected value' do
+    expect(Sys::Filesystem::VERSION).to eq('1.4.4')
+    expect(Sys::Filesystem::VERSION).to be_frozen
+  end
+
+  example 'you cannot instantiate an instance' do
+    expect{ described_class.new }.to raise_error(NoMethodError)
+  end
+end