file-find 0.5.0 → 0.5.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f6a005f38ff57e7ecba774576e6d8d8c005a386b50ec65197c4047cdd156d876
-  data.tar.gz: 50c000e4e15dd13bdab23fc396d0062ccc5392efd808036cc3df0a512f6ced50
+  metadata.gz: f1b89ade1ff89a891f6aa2a44fa801fa9d2758b3784074f8868a5b3319dc68a5
+  data.tar.gz: 52f17946eb45f73bd98b0804a9696e5e4d7c2f17d9ea002a20fa109fde7e10f3
 SHA512:
-  metadata.gz: '09d5c030c2312a89f03c21a69578ab08d437890151f943f37ebcf27cd62d51fb42694f833605207afbf8c2e6aeb2a7d852f9373a6bc251b5336d0933b6a0f082'
-  data.tar.gz: c2c7b029ba2fdf2ea2760e84ee5600ef5fa1670922d01924773688854edb9a7e2eee6b32581c25861ff5095c984c53ec86ffa54e7f4b71a3fda73d7dca732a26
+  metadata.gz: e6d0e1a56de403c2e7327f2d9af3ec6c68528d53f0cb0b83e40362b1ab8dddda020212cc726428ea0791130c098c1a41f53f22a65fad314d8dd9fee05fdc7fa3
+  data.tar.gz: 6c68a1b0e85905844b44feb04036834bb39e3ccaff5b732bb64d6280bb3eb86248f92f74570e60d37704fbc4d42ea4f99f2406c6d4be61ce7c9a8e3f89f1f1bb

checksums.yaml.gz.sig

@@ -1,2 +1 @@
-�U�w�!W�A�����	�I�K�(�kG�/�5С��[4yeW��}��,Va�a=�@�0�����\�yU%,��$��f_HA��c�ʣ��u�nu7��.��M���4{�@��{ed/�3��D�r�iq�b�f�X+�����^�� �����e���e���,��'�a�c��yU�a�(�g�e���2#���!B�d�F��vr�����Fod�~�˜��܇C	,�DJjAW�]��,w�|�s�ֶHf'����+x�_ݼX���Ҷ��h�
-)�f�Y_C�4��#a���a'|%*�C
iimuƄhz
+]����j
��]i�<ǝ�ٲ�Ԕ�X�|sN��l�!ʋ��TT�%wtF�W�8�g�s�]����Էâ�g�Z
!1y`���|���."qe'V�?���$W�n���)��RNf�ʍ��ޠ�2���qiN�6_��Si^/q��A?�~��Θ����=$�O�"���-���VB���$����|�����xc����פ6h�WZnc��{�P���ܲ0��w����N]�/:ݧ%����:�ω�#��O��.�X�D2+��o`V��9�D؀.㫐���>d���p�_2@t�6�ԧ���S·�=�ea1$-T��3|_��woP��BJ��g|�P�x�au��l���a�T�3��5�x.��5��_�

data/CHANGES.md

@@ -1,3 +1,11 @@
+## 0.5.1 - 17-Jun-2025
+* Updated, fixed or skipped some specs on Windows.
+* Some rubocop cleanup and minor refactors.
+* Added a github workflow matrix to the repo.
+* Added a rubocop config to the repo.
+* Minor tweaks to the Rakefile.
+* Added more information to the README.
+
 ## 0.5.0 - 19-Jan-2021
 * Switched from test-unit to rspec, with an added development
   dependency on the fakefs gem.

data/Gemfile

@@ -1,3 +1,2 @@
-source 'https://rubygems.org' do
-  gemspec
-end
+source 'https://rubygems.org'
+gemspec

data/README.md

@@ -1,3 +1,5 @@
+[![Ruby](https://github.com/djberg96/file-find/actions/workflows/ruby.yml/badge.svg)](https://github.com/djberg96/file-find/actions/workflows/ruby.yml)
+
 ## Description
 
 This is a drop-in replacement for the find module currently in the standard
@@ -7,6 +9,14 @@ library. It is modeled on a typical 'find' command found on most Unix systems.
 
 `gem install file-find`
 
+## Specs
+
+Although this gem will work with Ruby 2.x or 3.x, you will need Ruby 3.x to
+run the specs locally because of development dependencies.
+
+## Adding the trusted cert
+`gem cert --add <(curl -Ls https://raw.githubusercontent.com/djberg96/file-find/main/certs/djberg96_pub.pem)`
+
 ## Synopsis
 ```ruby
   require 'file/find' # 'file-find' also works
@@ -82,6 +92,9 @@ The `:perm` option is limited to 0644 and 0444 on MS Windows.
 The `:user`, `:group`, and `:inum` options require the win32-file gem to work
 properly on MS Windows. However, win32-file is not officially a dependency.
 
+Some specs on Windows are marked pending for now because there's some issue
+interacting with the FakeFS gem on Windows.
+
 ## Bugs
 
 None that I'm aware of beyond the ones mentioned in the Known Issues. Please
@@ -102,7 +115,7 @@ Apache-2.0
 
 ## Copyright
 
-(C) 2007-2021, Daniel J. Berger, All Rights Reserved
+(C) 2007-2025, Daniel J. Berger, All Rights Reserved
 
 ## Author
 

data/Rakefile

@@ -1,16 +1,17 @@
 require 'rake'
 require 'rake/clean'
 require 'rspec/core/rake_task'
+require 'rubocop/rake_task'
 
-CLEAN.include("**/*.gem", "**/*.rbc", "**/link*")
+CLEAN.include("**/*.gem", "**/*.rbc", "**/link*", "*.lock")
 
 namespace :gem do
   desc 'Create the file-find gem'
   task :create => [:clean] do
     require 'rubygems/package'
-    spec = eval(IO.read('file-find.gemspec'))
+    spec = Gem::Specification.load('file-find.gemspec')
     spec.signing_key = File.join(Dir.home, '.ssh', 'gem-private_key.pem')
-    Gem::Package.build(spec, true)
+    Gem::Package.build(spec)
   end
 
   desc "Install the file-find gem"
@@ -21,8 +22,15 @@ namespace :gem do
   end
 end
 
+RuboCop::RakeTask.new
+
 RSpec::Core::RakeTask.new(:spec) do |t|
   t.pattern = ['spec/file_find_spec.rb']
 end
 
+# Clean up afterwards
+Rake::Task[:spec].enhance do
+  Rake::Task[:clean].invoke
+end
+
 task :default => :spec

data/file-find.gemspec

@@ -2,7 +2,7 @@ require 'rubygems'
 
 Gem::Specification.new do |spec|
   spec.name       = 'file-find'
-  spec.version    = '0.5.0'
+  spec.version    = '0.5.1'
   spec.author     = 'Daniel Berger'
   spec.license    = 'Apache-2.0'
   spec.summary    = 'A better way to find files'
@@ -13,18 +13,23 @@ Gem::Specification.new do |spec|
   spec.cert_chain = Dir['certs/*']
 
   spec.metadata = {
-    'homepage_uri'      => 'https://github.com/djberg96/file-find',
-    'bug_tracker_uri'   => 'https://github.com/djberg96/file-find/issues',
-    'changelog_uri'     => 'https://github.com/djberg96/file-find/blob/master/CHANGES.md',
-    'documentation_uri' => 'https://github.com/djberg96/file-find/wiki',
-    'source_code_uri'   => 'https://github.com/djberg96/file-find',
-    'wiki_uri'          => 'https://github.com/djberg96/file-find/wiki'
+    'homepage_uri'          => 'https://github.com/djberg96/file-find',
+    'bug_tracker_uri'       => 'https://github.com/djberg96/file-find/issues',
+    'changelog_uri'         => 'https://github.com/djberg96/file-find/blob/main/CHANGES.md',
+    'documentation_uri'     => 'https://github.com/djberg96/file-find/wiki',
+    'source_code_uri'       => 'https://github.com/djberg96/file-find',
+    'wiki_uri'              => 'https://github.com/djberg96/file-find/wiki',
+    'rubygems_mfa_required' => 'true',
+    'github_repo'           => 'https://github.com/djberg96/file-find',
+    'funding_uri'           => 'https://github.com/sponsors/djberg96'
   }
 
   spec.add_dependency('sys-admin', '~> 1.7')
   spec.add_development_dependency('rspec', '~> 3.9')
-  spec.add_development_dependency('fakefs', '~> 1.3')
+  spec.add_development_dependency('fakefs', '~> 3.0')
   spec.add_development_dependency('rake')
+  spec.add_development_dependency('rubocop')
+  spec.add_development_dependency('rubocop-rspec')
 
   spec.description = <<-EOF
     The file-find library provides a better, more object oriented approach

data/lib/file/find.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'date'
 require 'sys/admin'
 
@@ -7,9 +9,11 @@ rescue LoadError
   # Do nothing, not required, just nicer.
 end
 
+# The File::Find class encapsulates 'rules' that you create and use to find
+# files on your filesystem.
 class File::Find
   # The version of the file-find library
-  VERSION = '0.5.0'.freeze
+  VERSION = '0.5.1'
 
   # :stopdoc:
   VALID_OPTIONS = %w[
@@ -31,7 +35,7 @@ class File::Find
     prune
     size
     user
-  ]
+  ].freeze
   # :startdoc:
 
   # The starting path(s) for the search. The default is the current directory.
@@ -209,6 +213,7 @@ class File::Find
   def find
     results = [] unless block_given?
     paths   = @path.is_a?(String) ? [@path] : @path # Ruby 1.9.x compatibility
+    queue   = paths.dup
 
     if @prune
       prune_regex = Regexp.new(@prune)
@@ -216,14 +221,16 @@ class File::Find
       prune_regex = nil
     end
 
-    paths.each{ |path|
+    # rubocop:disable Metrics/BlockLength
+    until queue.empty?
+      path = queue.shift
       begin
-        Dir.foreach(path){ |file|
+        Dir.foreach(path) do |file|
           next if file == '.'
           next if file == '..'
 
-          if prune_regex
-            next if prune_regex.match(file)
+          if prune_regex && prune_regex.match(file)
+            next
           end
 
           file = File.join(path, file)
@@ -251,38 +258,32 @@ class File::Find
             glob.tr!(File::ALT_SEPARATOR, File::SEPARATOR)
           end
 
-          if @mount
-            next unless stat_info.dev == @filesystem
+          if @mount && stat_info.dev != @filesystem
+            next
           end
 
-          if @links
-            next unless stat_info.nlink == @links
+          if @links && stat_info.nlink != @links
+            next
           end
 
           if @maxdepth || @mindepth
-            file_depth = file.split(File::SEPARATOR).reject{ |e| e.size.zero? }.length
+            file_depth = file.split(File::SEPARATOR).reject(&:empty?).length
             current_base_path = [@path].flatten.find{ |tpath| file.include?(tpath) }
             path_depth = current_base_path.split(File::SEPARATOR).length
 
             depth = file_depth - path_depth
 
             if @maxdepth && (depth > @maxdepth)
-              if File.directory?(file)
-                unless paths.include?(file) && depth > @maxdepth
-                  paths << file
-                end
+              if File.directory?(file) && !(paths.include?(file) && depth > @maxdepth)
+                queue << file
               end
-
               next
             end
 
             if @mindepth && (depth < @mindepth)
-              if File.directory?(file)
-                unless paths.include?(file) && depth < @mindepth
-                  paths << file
-                end
+              if File.directory?(file) && !(paths.include?(file) && depth < @mindepth)
+                queue << file
               end
-
               next
             end
           end
@@ -290,8 +291,8 @@ class File::Find
           # Add directories back onto the list of paths to search unless
           # they've already been added
           #
-          if stat_info.directory?
-            paths << file unless paths.include?(file)
+          if stat_info.directory? && !paths.include?(file)
+            queue << file
           end
 
           next unless Dir[glob].include?(file)
@@ -299,7 +300,7 @@ class File::Find
           unless @filetest.empty?
             file_test = true
 
-            @filetest.each{ |array|
+            @filetest.each do |array|
               meth = array[0]
               bool = array[1]
 
@@ -307,7 +308,7 @@ class File::Find
                 file_test = false
                 break
               end
-            }
+            end
 
             next unless file_test
           end
@@ -331,8 +332,8 @@ class File::Find
             end
           end
 
-          if @ftype
-            next unless File.ftype(file) == @ftype
+          if @ftype && File.ftype(file) != @ftype
+            next
           end
 
           if @group
@@ -355,8 +356,8 @@ class File::Find
             end
           end
 
-          if @inum
-            next unless stat_info.ino == @inum
+          if @inum && stat_info.ino != @inum
+            next
           end
 
           # Note that only 0644 and 0444 are supported on MS Windows.
@@ -365,7 +366,7 @@ class File::Find
               octal_perm = sym2oct(@perm)
               next unless stat_info.mode & octal_perm == octal_perm
             else
-              next unless sprintf("%o", stat_info.mode & 07777) == sprintf("%o", @perm)
+              next unless format('%o', stat_info.mode & 07777) == format('%o', @perm)
             end
           end
 
@@ -415,11 +416,12 @@ class File::Find
           end
 
           @previous = file unless @previous == file
-        }
+        end
       rescue Errno::EACCES
         next # Skip inaccessible directories
       end
-    }
+    end
+    # rubocop:enable Metrics/BlockLength
 
     block_given? ? nil : results
   end
@@ -476,17 +478,17 @@ class File::Find
       match = cmd.match(regex)
       raise "Invalid symbolic permissions: '#{str}'" if match.nil?
 
-      who, what, how = match.to_a[1..-1]
+      who, what, how = match.to_a[1..]
 
-      who  = who.split(//).inject(0){ |num,b| num |= left[b]; num }
-      how  = how.split(//).inject(0){ |num,b| num |= right[b]; num }
+      who  = who.chars.inject(0){ |num, b| num | left[b] }
+      how  = how.chars.inject(0){ |num, b| num | right[b] }
       mask = who & how
 
       case what
         when '+'
-          perm = perm | mask
+          perm |= mask
         when '-'
-          perm = perm & ~mask
+          perm &= ~mask
         when '='
           perm = mask
       end

data/lib/file-find.rb

@@ -1 +1,3 @@
+# frozen_string_literal: true
+
 require_relative 'file/find'

data/spec/file_find_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 ######################################################################
 # file_find_spec.rb
 #
@@ -7,136 +9,136 @@
 require 'rspec'
 require 'file-find'
 require 'sys-admin'
-require 'pp' # stops fakefs class mismatch errors
 require 'tmpdir'
+require 'pp' # Goofy workaround for FakeFS bug
 require 'fakefs/spec_helpers'
 
 RSpec.describe File::Find do
   include FakeFS::SpecHelpers
 
   let(:windows)    { File::ALT_SEPARATOR }
+  let(:elevated)   { windows and Win32::Security.elevated_security? }
   let(:ruby_file)  { 'file_find_test.rb' }
   let(:doc_file)   { 'file_find_test.doc' }
-  let(:text_file1) { 'file_find_test1.txt' }
-  let(:text_file2) { 'file_find_test2.txt' }
 
-  let(:rule) { File::Find.new }
-  let(:txt_rule) { File::Find.new(:name => '*.txt') }
+  let(:rule) { described_class.new }
+  let(:txt_rule) { described_class.new(:name => '*.txt') }
 
   before(:all) do
     @loguser = Sys::Admin.get_user(Sys::Admin.get_login)
-    @logroup = Sys::Admin.get_group(@loguser.gid)
+    group = File::ALT_SEPARATOR ? 'Users' : @loguser.gid
+    @logroup = Sys::Admin.get_group(group)
   end
 
-  context "constants", :constants => true do
-    example "version constant is set to expected value" do
-      expect(File::Find::VERSION).to eq('0.5.0')
+  context 'constants', :constants do
+    example 'version constant is set to expected value' do
+      expect(File::Find::VERSION).to eq('0.5.1')
       expect(File::Find::VERSION).to be_frozen
     end
   end
 
-  context "path", :path => true do
-    example "path accessor basic functionality" do
+  context 'path', :path do
+    example 'path accessor basic functionality' do
       expect(rule).to respond_to(:path)
       expect(rule).to respond_to(:path=)
     end
 
-    example "path method returns expected value" do
+    example 'path method returns expected value' do
       expect(rule.path).to eq(Dir.pwd)
     end
   end
 
-  context "options", :options => true do
-    example "options accessor basic functionality" do
+  context 'options', :options do
+    example 'options accessor basic functionality' do
       expect(rule).to respond_to(:options)
       expect(rule).to respond_to(:options=)
     end
 
-    example "options method returns expected value" do
+    example 'options method returns expected value' do
       expect(txt_rule.options).to eq({:name => '*.txt'})
     end
   end
 
-  context "atime", :atime => true do
+  context 'atime', :atime do
     before do
       FileUtils.touch(ruby_file)
     end
 
-    example "atime accessor basic functionality" do
+    example 'atime accessor basic functionality' do
       expect(rule).to respond_to(:atime)
       expect(rule).to respond_to(:atime=)
     end
 
-    example "atime method returns expected default value" do
+    example 'atime method returns expected default value' do
       expect(rule.atime).to be_nil
     end
 
-    example "find with atime option works as expected" do
-      rule1 = File::Find.new(:name => "*.rb", :atime => 0)
-      rule2 = File::Find.new(:name => "*.rb", :atime => 1)
+    example 'find with atime option works as expected' do
+      rule1 = described_class.new(:name => '*.rb', :atime => 0)
+      rule2 = described_class.new(:name => '*.rb', :atime => 1)
 
       expect(rule1.find.empty?).to be false
       expect(rule2.find.empty?).to be true
     end
   end
 
-  context "ctime", :ctime => true do
+  context 'ctime', :ctime do
     before do
       FileUtils.touch(ruby_file)
     end
 
-    example "ctime accessor basic functionality" do
+    example 'ctime accessor basic functionality' do
       expect(rule).to respond_to(:ctime)
       expect(rule).to respond_to(:ctime=)
     end
 
-    example "ctime method returns expected default value" do
+    example 'ctime method returns expected default value' do
       expect(rule.ctime).to be_nil
     end
 
-    example "find with ctime option works as expected" do
-      rule1 = File::Find.new(:name => "*.rb", :ctime => 0)
-      rule2 = File::Find.new(:name => "*.rb", :ctime => 1)
+    example 'find with ctime option works as expected' do
+      rule1 = described_class.new(:name => '*.rb', :ctime => 0)
+      rule2 = described_class.new(:name => '*.rb', :ctime => 1)
 
       expect(rule1.find.empty?).to be false
       expect(rule2.find.empty?).to be true
     end
   end
 
-  context "find", :find => true do
-    example "find method basic functionality" do
+  context 'find', :find do
+    example 'find method basic functionality' do
       expect(rule).to respond_to(:find)
       expect{ rule.find }.not_to raise_error
     end
 
-    example "find method returns expected value" do
-      expect(rule.find).to be_kind_of(Array)
+    example 'find method returns expected value' do
+      expect(rule.find).to be_a(Array)
       expect(rule.find{}).to be_nil
     end
   end
 
-  context "filetest", :filetest => true do
+  context 'filetest', :filetest do
     before do
       FileUtils.touch(doc_file, :mode => 0644)
     end
 
-    example "filetest accessor basic functionality" do
+    example 'filetest accessor basic functionality' do
       expect(rule).to respond_to(:filetest)
       expect(rule).to respond_to(:filetest=)
       expect{ rule.filetest }.not_to raise_error
     end
 
-    example "filetest method returns expected value" do
-      expect(rule.filetest).to be_kind_of(Array)
+    example 'filetest method returns expected value' do
+      expect(rule.filetest).to be_a(Array)
     end
 
-    example "valid filetest options work as expected" do
-      expect{ File::Find.new(:readable? => true) }.not_to raise_error
-      expect{ File::Find.new(:writable? => true) }.not_to raise_error
+    example 'valid filetest options work as expected' do
+      expect{ described_class.new(:readable? => true) }.not_to raise_error
+      expect{ described_class.new(:writable? => true) }.not_to raise_error
     end
 
-    example "find method works with filetest option" do
-      rule = File::Find.new(:name => "*.doc", :writable? => true)
+    example 'find method works with filetest option' do
+      rule = described_class.new(:name => '*.doc', :writable? => true)
 
       expect(rule.find.map{ |f| File.basename(f) }).to eq([doc_file])
       FileUtils.chmod(0444, doc_file)
@@ -144,165 +146,158 @@ RSpec.describe File::Find do
     end
   end
 
-  context "mtime", :mtime => true do
+  context 'mtime', :mtime do
     before do
       FileUtils.touch(ruby_file)
     end
 
-    example "mtime accessor basic functionality" do
+    example 'mtime accessor basic functionality' do
       expect(rule).to respond_to(:mtime)
       expect(rule).to respond_to(:mtime=)
     end
 
-    example "mtime method returns expected default value" do
+    example 'mtime method returns expected default value' do
       expect(rule.mtime).to be_nil
     end
 
-    example "find with mtime option works as expected" do
-      rule1 = File::Find.new(:name => "*.rb", :mtime => 0)
-      rule2 = File::Find.new(:name => "*.rb", :mtime => 1)
+    example 'find with mtime option works as expected' do
+      rule1 = described_class.new(:name => '*.rb', :mtime => 0)
+      rule2 = described_class.new(:name => '*.rb', :mtime => 1)
 
       expect(rule1.find.empty?).to be false
       expect(rule2.find.empty?).to be true
     end
   end
 
-  context "ftype", :ftype => true do
+  context 'ftype', :ftype do
     before do
       FileUtils.touch(ruby_file)
     end
 
-    example "ftype accessor basic functionality" do
+    example 'ftype accessor basic functionality' do
       expect(rule).to respond_to(:ftype)
       expect(rule).to respond_to(:ftype=)
     end
 
-    example "ftype method returns expected default value" do
+    example 'ftype method returns expected default value' do
       expect(rule.ftype).to be_nil
     end
 
-    example "ftype method works as expected" do
-      rule1 = File::Find.new(:name => "*.rb", :ftype => "file")
-      rule2 = File::Find.new(:name => "*.rb", :ftype => "characterSpecial")
+    example 'ftype method works as expected' do
+      rule1 = described_class.new(:name => '*.rb', :ftype => 'file')
+      rule2 = described_class.new(:name => '*.rb', :ftype => 'characterSpecial')
 
       expect(rule1.find.empty?).to be false
       expect(rule2.find.empty?).to be true
     end
   end
 
-  context "group", :group => true do
+  context 'group', :group do
     before do
       FileUtils.touch(doc_file)
     end
 
-    example "group accessor basic functionality" do
+    example 'group accessor basic functionality' do
       expect(rule).to respond_to(:group)
       expect(rule).to respond_to(:group=)
     end
 
-    example "group method returns expected default value" do
+    example 'group method returns expected default value' do
       expect(rule.group).to be_nil
     end
 
     # TODO: Update example for Windows
-    example "find with numeric group id works as expected" do
+    example 'find with numeric group id works as expected' do
       skip 'group example skipped on MS Windows' if windows
-      rule = File::Find.new(:name => '*.doc', :group => @loguser.gid)
+      rule = described_class.new(:name => '*.doc', :group => @loguser.gid)
       expect(rule.find).to eq([File.expand_path(doc_file)])
     end
 
     # TODO: Update example for Windows
-    example "find with string group id works as expected" do
+    example 'find with string group id works as expected' do
       skip 'group example skipped on MS Windows' if windows
 
-      rule = File::Find.new(:name => '*.doc', :group => @logroup.name)
+      rule = described_class.new(:name => '*.doc', :group => @logroup.name)
       expect(rule.find).to eq([File.expand_path(doc_file)])
     end
 
-    example "find with bogus group returns empty results" do
+    example 'find with bogus group returns empty results' do
       skip 'group test skipped on MS Windows' if windows
 
-      rule1 = File::Find.new(:name => '*.doc', :group => 'totallybogus')
-      rule2 = File::Find.new(:name => '*.doc', :group => 99999999)
+      rule1 = described_class.new(:name => '*.doc', :group => 'totallybogus')
+      rule2 = described_class.new(:name => '*.doc', :group => 99999999)
       expect(rule1.find).to eq([])
       expect(rule2.find).to eq([])
     end
   end
 
-  context "inum", :inum => true do
-    example "inum accessor basic functionality" do
+  context 'inum', :inum do
+    example 'inum accessor basic functionality' do
       expect(rule).to respond_to(:inum)
       expect(rule).to respond_to(:inum=)
     end
 
-    example "inum method returns expected default value" do
+    example 'inum method returns expected default value' do
       expect(rule.inum).to be_nil
     end
   end
 
-  context "follow", :follow => true do
-    example "follow accessor basic functionality" do
+  context 'follow', :follow do
+    example 'follow accessor basic functionality' do
       expect(rule).to respond_to(:follow)
       expect(rule).to respond_to(:follow=)
     end
 
-    example "follow method returns expected default value" do
+    example 'follow method returns expected default value' do
       expect(rule.follow).to be true
     end
   end
 
-  context "links", :links => true do
+  context 'links', :links do
     before do
       FileUtils.touch(ruby_file)
       FileUtils.touch(doc_file)
     end
 
-    example "links accessor basic functionality" do
+    example 'links accessor basic functionality' do
       expect(rule).to respond_to(:links)
       expect(rule).to respond_to(:links=)
     end
 
-    example "links method returns expected default value" do
+    example 'links method returns expected default value' do
       expect(rule.links).to be_nil
     end
 
-    example "links method returns expected result" do
-      # skip if @@windows && !@@elevated # TODO: Update
+    example 'links method returns expected result' do
+      skip if windows && !elevated
 
-      rule1 = File::Find.new(:name => '*.rb', :links => 2)
-      rule2 = File::Find.new(:name => '*.doc', :links => 1)
+      rule1 = described_class.new(:name => '*.rb', :links => 2)
+      rule2 = described_class.new(:name => '*.doc', :links => 1)
 
       expect(rule1.find).to eq([])
       expect(rule2.find).to eq([File.expand_path(doc_file)])
     end
   end
 
-  context "brackets", :brackets => true do
+  context 'brackets', :brackets do
+    let(:file_rule){ described_class.new(:ftype => 'file', :path => ['/bracket']) }
+    let(:dir_rule){ described_class.new(:ftype => 'directory', :path => ['/bracket']) }
+
     before do
       allow(FakeFS::FileSystem).to receive(:find).and_call_original
       allow(FakeFS::FileSystem).to receive(:find).with(anything, 0, false)
     end
 
-    example "find method works on dirs that contain brackets" do
+    example 'find method works on dirs that contain brackets' do
       skip 'dirs with brackets example skipped on MS Windows' if windows
 
       # We use absolute paths here because of fakefs, which converts it anyway
-      bracket_files = ['/bracket/a[1]/a.foo', '/bracket/a [2] /b.foo', '/bracket/[a] b [c]/d.foo' ]
-      bracket_paths = ['/bracket/a[1]', '/bracket/a [2] ', '/bracket/[a] b [c]', '/bracket/[z] x' ]
+      bracket_files = ['/bracket/a[1]/a.foo', '/bracket/a [2] /b.foo', '/bracket/[a] b [c]/d.foo']
+      bracket_paths = ['/bracket/a[1]', '/bracket/a [2] ', '/bracket/[a] b [c]', '/bracket/[z] x']
 
       bracket_paths.each{ |e| FakeFS::FileSystem.add(e) }
       bracket_files.each{ |e| FileUtils.touch(e) }
 
-      file_rule = File::Find.new(
-        :ftype => 'file',
-        :path  => ['/bracket']
-      )
-
-      dir_rule = File::Find.new(
-        :ftype => 'directory',
-        :path => ['/bracket']
-      )
-
       file_results = file_rule.find
       dir_results = dir_rule.find
 
@@ -311,10 +306,10 @@ RSpec.describe File::Find do
     end
   end
 
-  context "maxdepth", :maxdepth => true do
+  context 'maxdepth', :maxdepth do
     before do
-      fs = FakeFS::FileSystem.add('a1/a2/a3')
-      rule.pattern = "*.foo"
+      FakeFS::FileSystem.add('a1/a2/a3')
+      rule.pattern = '*.foo'
 
       FileUtils.touch('a1/a.foo')
       FileUtils.touch('a1/a2/b.foo')
@@ -324,48 +319,60 @@ RSpec.describe File::Find do
       FileUtils.touch('a1/a2/a3/f.foo')
     end
 
-    example "maxdepth_basic" do
+    example 'maxdepth_basic' do
       expect(rule).to respond_to(:maxdepth)
       expect(rule).to respond_to(:maxdepth=)
       expect(rule.maxdepth).to be_nil
     end
 
-    example "find with maxdepth option returns expected results" do
+    example 'find with maxdepth 1 returns expected results' do
       rule.maxdepth = 1
-
       expect(rule.find).to eq([])
+    end
 
+    example 'find with maxdepth 2 returns expected results' do
+      pending if windows
       rule.maxdepth = 2
       expect(rule.find.map{ |e| File.basename(e) }).to eq(['a.foo'])
+    end
 
+    example 'find with maxdepth 3 returns expected results' do
+      pending if windows
       rule.maxdepth = 3
-      expect(rule.find.map{ |e| File.basename(e) }).to match_array(['a.foo', 'b.foo', 'c.foo'])
+      expect(rule.find.map{ |e| File.basename(e) }).to contain_exactly('a.foo', 'b.foo', 'c.foo')
     end
 
-    example "find with nil maxdepth option returns everything" do
+    example 'find with nil maxdepth option returns everything' do
+      pending if windows
       rule.maxdepth = nil
       results = ['a.foo', 'b.foo', 'c.foo', 'd.foo', 'e.foo', 'f.foo']
       expect(rule.find.map{ |e| File.basename(e) }).to match_array(results)
     end
 
-    example "find with maxdepth option returns expected results for directories" do
-      rule.pattern = "a3"
-
+    example 'find with maxdepth 1 returns expected results for directories' do
+      rule.pattern = 'a3'
       rule.maxdepth = 1
       expect(rule.find).to eq([])
+    end
 
+    example 'find with maxdepth 2 returns expected results for directories' do
+      rule.pattern = 'a3'
       rule.maxdepth = 2
       expect(rule.find).to eq([])
+    end
 
+    example 'find with maxdepth 3 returns expected results for directories' do
+      pending if windows
+      rule.pattern = 'a3'
       rule.maxdepth = 3
       expect(rule.find.map{ |e| File.basename(e) }).to eq(['a3'])
     end
   end
 
-  context "mindepth", :mindepth => true do
+  context 'mindepth', :mindepth do
     before do
-      fs = FakeFS::FileSystem.add('a1/a2/a3')
-      rule.pattern = "*.min"
+      FakeFS::FileSystem.add('a1/a2/a3')
+      rule.pattern = '*.min'
 
       FileUtils.touch('z.min')
       FileUtils.touch('a1/a.min')
@@ -376,52 +383,57 @@ RSpec.describe File::Find do
       FileUtils.touch('a1/a2/a3/f.min')
     end
 
-    example "mindepth accessor basic functionality" do
+    example 'mindepth accessor basic functionality' do
       expect(rule).to respond_to(:mindepth)
       expect(rule).to respond_to(:mindepth=)
       expect(rule.mindepth).to be_nil
     end
 
-    example "mindepth method returns expected default value" do
+    example 'mindepth method returns expected default value' do
       expect(rule.mindepth).to be_nil
     end
 
-    example "find with mindepth option returns expected results at depth 0" do
+    example 'find with mindepth option returns expected results at depth 0' do
+      pending if windows
       rule.mindepth = 0
       array = ['a.min', 'b.min', 'c.min', 'd.min', 'e.min', 'f.min', 'z.min']
       expect(rule.find.map{ |e| File.basename(e) }).to match_array(array)
     end
 
-    example "find with mindepth option returns expected results at depth 1" do
+    example 'find with mindepth option returns expected results at depth 1' do
+      pending if windows
       rule.mindepth = 1
       array = ['a.min', 'b.min', 'c.min', 'd.min', 'e.min', 'f.min', 'z.min']
       expect(rule.find.map{ |e| File.basename(e) }).to match_array(array)
     end
 
-    example "find with mindepth option returns expected results at depth 2" do
+    example 'find with mindepth option returns expected results at depth 2' do
+      pending if windows
       rule.mindepth = 2
       array = ['a.min', 'b.min', 'c.min', 'd.min', 'e.min', 'f.min']
       expect(rule.find.map{ |e| File.basename(e) }).to match_array(array)
     end
 
-    example "find with mindepth option returns expected results at depth 3" do
+    example 'find with mindepth option returns expected results at depth 3' do
+      pending if windows
       rule.mindepth = 3
       array = ['b.min', 'c.min', 'd.min', 'e.min', 'f.min']
       expect(rule.find.map{ |e| File.basename(e) }).to match_array(array)
     end
 
-    example "find with mindepth option returns expected results at depth 4" do
+    example 'find with mindepth option returns expected results at depth 4' do
+      pending if windows
       rule.mindepth = 4
       array = ['d.min', 'e.min', 'f.min']
       expect(rule.find.map{ |e| File.basename(e) }).to match_array(array)
     end
 
-    example "find with mindepth option returns expected results at depth 5" do
+    example 'find with mindepth option returns expected results at depth 5' do
       rule.mindepth = 5
       expect(rule.find.map{ |e| File.basename(e) }).to eq([])
     end
 
-    example "find with mindepth option returns expected results for directories" do
+    example 'find with mindepth option returns expected results for directories' do
       rule.pattern = 'a1'
       rule.mindepth = 1
 
@@ -435,34 +447,37 @@ RSpec.describe File::Find do
     end
   end
 
-  context "mount", :mount => true do
-    example "mount accessor basic functionality" do
+  context 'mount', :mount do
+    example 'mount accessor basic functionality' do
       expect(rule).to respond_to(:mount)
       expect(rule).to respond_to(:mount=)
     end
 
-    example "mount method returns expected default value" do
+    example 'mount method returns expected default value' do
       expect(rule.mount).to be_nil
     end
   end
 
-  context "name", :name => true do
-    example "name accessor basic functionality" do
+  context 'name', :name do
+    example 'name accessor basic functionality' do
       expect(rule).to respond_to(:name)
       expect(rule).to respond_to(:name=)
     end
 
-    example "name method returns expected default value" do
+    example 'name method returns expected default value' do
       expect(txt_rule.name).to eq('*.txt')
     end
 
-    example "pattern is an alias for name" do
+    example 'pattern is an alias for name' do
       expect(rule.method(:name)).to eq(rule.method(:pattern))
       expect(rule.method(:name=)).to eq(rule.method(:pattern=))
     end
   end
 
-  context "perm", :perm => true do
+  context 'perm', :perm do
+    let(:text_file1) { 'file_find_test1.txt' }
+    let(:text_file2) { 'file_find_test2.txt' }
+
     before do
       FileUtils.touch(ruby_file)
       FileUtils.touch(text_file1)
@@ -472,27 +487,27 @@ RSpec.describe File::Find do
       File.chmod(0644, text_file2)
     end
 
-    example "perm accessor basic functionality" do
+    example 'perm accessor basic functionality' do
       expect(rule).to respond_to(:perm)
       expect(rule).to respond_to(:perm=)
     end
 
-    example "perm method returns expected default value" do
+    example 'perm method returns expected default value' do
       expect(rule.perm).to be_nil
     end
 
-    example "perm method returns expected results" do
-      results = File::Find.new(:name => "*test1*", :perm => 0644).find
+    example 'perm method returns expected results' do
+      results = described_class.new(:name => '*test1*', :perm => 0644).find
 
       expect(results.length).to eq(1)
       expect(File.basename(results.first)).to eq(text_file1)
     end
 
-    example "perm method works with symbolic permissions" do
+    example 'perm method works with symbolic permissions' do
       skip 'symbolic perm spec skipped on MS Windows' if windows
 
-      results1 = File::Find.new(:name => "file*", :perm => "g=rw").find
-      results2 = File::Find.new(:name => "file*", :perm => "u=rw").find
+      results1 = described_class.new(:name => 'file*', :perm => 'g=rw').find
+      results2 = described_class.new(:name => 'file*', :perm => 'u=rw').find
 
       expect(results1.length).to eq(1)
       expect(results2.length).to eq(2)
@@ -501,97 +516,107 @@ RSpec.describe File::Find do
     end
   end
 
-  context "prune", :prune => true do
+  context 'prune', :prune do
+    let(:prune_file) { 'file_find_test_prune.txt' }
+
     before do
-      FileUtils.touch(text_file1)
+      FileUtils.touch(prune_file)
     end
 
-    example "prune accessor basic functionality" do
+    example 'prune accessor basic functionality' do
       expect(rule).to respond_to(:prune)
       expect(rule).to respond_to(:prune=)
     end
 
-    example "prune method returns expected default value" do
+    example 'prune method returns expected default value' do
       expect(rule.prune).to be_nil
     end
 
-    example "find method with prune option works as expected" do
-      rule = File::Find.new(:name => "*.txt", :prune => 'foo')
-      expect(File.basename(rule.find.first)).to eq(text_file1)
+    example 'find method with prune option works as expected' do
+      rule = described_class.new(:name => '*.txt', :prune => 'foo')
+      expect(File.basename(rule.find.first)).to eq(prune_file)
     end
   end
 
-  context "size", :size => true do
-    example "size accessor basic functionality" do
+  context 'size', :size do
+    example 'size accessor basic functionality' do
       expect(rule).to respond_to(:size)
       expect(rule).to respond_to(:size=)
     end
 
-    example "size method returns expected default value" do
+    example 'size method returns expected default value' do
       expect(rule.size).to be_nil
     end
   end
 
-  context "user", :user => true do
+  context 'user', :user do
     before do
       FileUtils.touch(doc_file)
     end
 
-    example "user accessor basic functionality" do
+    example 'user accessor basic functionality' do
       expect(rule).to respond_to(:user)
       expect(rule).to respond_to(:user=)
     end
 
-    example "user method returns expected default value" do
+    example 'user method returns expected default value' do
       expect(rule.user).to be_nil
     end
 
-    example "user method works with numeric id as expected" do
+    example 'user method works with numeric id as expected' do
+      pending if windows # TODO: Get this working on Windows
+
       if windows && elevated
         uid = @loguser.gid # Windows assigns the group if any member is an admin
       else
         uid = @loguser.uid
       end
 
-      rule = File::Find.new(:name => '*.doc', :user => uid)
+      rule = described_class.new(:name => '*.doc', :user => uid)
       expect(rule.find).to eq([File.expand_path(doc_file)])
     end
 
-    example "user method works with string as expected" do
+    example 'user method works with string as expected' do
+      pending if windows # TODO: Get this working on Windows
+
       skip if windows && elevated
-      rule = File::Find.new(:name => '*.doc', :user => @loguser.name)
+      rule = described_class.new(:name => '*.doc', :user => @loguser.name)
       expect(rule.find).to eq([File.expand_path(doc_file)])
     end
 
-    example "find method with user option using invalid user returns expected results" do
-      rule1 = File::Find.new(:name => '*.doc', :user => 'totallybogus')
-      rule2 = File::Find.new(:name => '*.doc', :user => 99999999)
+    example 'find method with user option using invalid user returns expected results' do
+      rule1 = described_class.new(:name => '*.doc', :user => 'totallybogus')
+      rule2 = described_class.new(:name => '*.doc', :user => 99999999)
       expect(rule1.find).to eq([])
       expect(rule2.find).to eq([])
     end
   end
 
-  context "previous", :previous => true do
-    example "previous method basic functionality" do
+  context 'previous', :previous do
+    example 'previous method basic functionality' do
       expect(rule).to respond_to(:previous)
     end
   end
 
-  example "an error is raised if the path does not exist" do
-    expect{ File::Find.new(:path => '/bogus/dir').find }.to raise_error(Errno::ENOENT)
+  example 'an error is raised if the path does not exist' do
+    expect{ described_class.new(:path => '/bogus/dir').find }.to raise_error(Errno::ENOENT)
   end
 
-  example "an error is raised if an invalid option is passed" do
-    expect{ File::Find.new(:bogus => 1) }.to raise_error(ArgumentError)
-    expect{ File::Find.new(:bogus? => true) }.to raise_error(ArgumentError)
+  example 'an error is raised if an invalid option is passed' do
+    expect{ described_class.new(:bogus => 1) }.to raise_error(ArgumentError)
+    expect{ described_class.new(:bogus? => true) }.to raise_error(ArgumentError)
   end
 
-  context "eloop", :eloop => true do
+  context 'eloop', :eloop do
     # Have to disable fakefs for this test because of bug: https://github.com/fakefs/fakefs/issues/459
     before do
       FakeFS.deactivate!
     end
 
+    after do
+      FakeFS.activate!
+    end
+
     # TODO: Update example for Windows
     example 'eloop handling works as expected' do
       skip 'eloop handling example skipped on MS Windows' if windows
@@ -601,13 +626,9 @@ RSpec.describe File::Find do
         File.symlink('eloop1', 'eloop0')
         expected = ['./eloop0', './eloop1']
 
-        results = File::Find.new(:path => '.', :follow => true).find
+        results = described_class.new(:path => '.', :follow => true).find
         expect(results.sort).to eq(expected)
       end
     end
-
-    after do
-      FakeFS.activate!
-    end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: file-find
 version: !ruby/object:Gem::Version
-  version: 0.5.0
+  version: 0.5.1
 platform: ruby
 authors:
 - Daniel Berger
@@ -35,7 +35,7 @@ cert_chain:
   ORVCZpRuCPpmC8qmqxUnARDArzucjaclkxjLWvCVHeFa9UP7K3Nl9oTjJNv+7/jM
   WZs4eecIcUc4tKdHxcAJ0MO/Dkqq7hGaiHpwKY76wQ1+8xAh
   -----END CERTIFICATE-----
-date:
+date: 2025-06-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: sys-admin
@@ -71,14 +71,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.3'
+        version: '3.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.3'
+        version: '3.0'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -93,6 +93,34 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rubocop-rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: |2
       The file-find library provides a better, more object oriented approach
       to finding files. It allows you to find files based on a variety of
@@ -103,31 +131,30 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- CHANGES.md
+- Gemfile
 - LICENSE
-- file-find.gemspec
-- spec
-- spec/file_find_spec.rb
+- MANIFEST.md
 - README.md
 - Rakefile
-- MANIFEST.md
-- certs
 - certs/djberg96_pub.pem
-- lib
+- file-find.gemspec
 - lib/file-find.rb
-- lib/file
 - lib/file/find.rb
-- Gemfile
-- CHANGES.md
+- spec/file_find_spec.rb
 homepage: http://github.com/djberg96/file-find
 licenses:
 - Apache-2.0
 metadata:
   homepage_uri: https://github.com/djberg96/file-find
   bug_tracker_uri: https://github.com/djberg96/file-find/issues
-  changelog_uri: https://github.com/djberg96/file-find/blob/master/CHANGES.md
+  changelog_uri: https://github.com/djberg96/file-find/blob/main/CHANGES.md
   documentation_uri: https://github.com/djberg96/file-find/wiki
   source_code_uri: https://github.com/djberg96/file-find
   wiki_uri: https://github.com/djberg96/file-find/wiki
+  rubygems_mfa_required: 'true'
+  github_repo: https://github.com/djberg96/file-find
+  funding_uri: https://github.com/sponsors/djberg96
 post_install_message:
 rdoc_options: []
 require_paths:
@@ -143,7 +170,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.3
+rubygems_version: 3.5.22
 signing_key:
 specification_version: 4
 summary: A better way to find files