file-find 0.4.4 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d99bb72ba56fc51995a186e6f06869318c1f29b1965d49d8aa42853aa341bf57
-  data.tar.gz: c04db8e76c5a4ab4f953a373a6d089379cf4f99064ec18883a70ed7db1d82963
+  metadata.gz: f6a005f38ff57e7ecba774576e6d8d8c005a386b50ec65197c4047cdd156d876
+  data.tar.gz: 50c000e4e15dd13bdab23fc396d0062ccc5392efd808036cc3df0a512f6ced50
 SHA512:
-  metadata.gz: bac0f7a26c507ae51dd15a19611bb0af91f43a93a717cf32a0c6787b244abb4680b8b12372525b51635696a4aa2c11f312107c1374c16f5f891c7d53cba111d8
-  data.tar.gz: d27462d46d37ad567c9d7eaa29cadd7962e08066850d75a4b35983feb0a81a03ad63e224b10348099da0ffe74992b4604a576099dd1fde4f81f401d678d9baf5
+  metadata.gz: '09d5c030c2312a89f03c21a69578ab08d437890151f943f37ebcf27cd62d51fb42694f833605207afbf8c2e6aeb2a7d852f9373a6bc251b5336d0933b6a0f082'
+  data.tar.gz: c2c7b029ba2fdf2ea2760e84ee5600ef5fa1670922d01924773688854edb9a7e2eee6b32581c25861ff5095c984c53ec86ffa54e7f4b71a3fda73d7dca732a26

checksums.yaml.gz.sig

@@ -1,6 +1,2 @@
-h��߼�ɢϵ�g�Ï���o��($����>�u��J����D'���� ���nO�am� ����>�)��z+������?ސ����^O��"Ѫ	>v�d�O&��^�_9��/����:;µu
-xߎ\���Iv2�U��
-~��ẖq���B9AH�麋EPu�i��w3��楚2�M��Ӆ�>k�(�?��2��	�$y�j�Gu]�0J�z���#�,�'>�
-��9���'�~��RJE}�8{'�λ[�*ߗ
-b����۳w��X{�ţ;xE�%
-�9po�'���� k	e~�Oi��Nۡ��@,����HsV�nJj�w��uD
+�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

data/{CHANGES.rdoc → CHANGES.md}

@@ -1,25 +1,36 @@
-== 0.4.3 - 8-Jun-2020
+## 0.5.0 - 19-Jan-2021
+* Switched from test-unit to rspec, with an added development
+  dependency on the fakefs gem.
+* Switched from rdoc to markdown because github doesn't render rdoc
+  properly any more.
+* Fixed a bug in the maxdepth option with root paths.
+* Added a Gemfile.
+
+## 0.4.4 - 6-Aug-2020
+* Added .rdoc extensions to the CHANGES, README and MANIFEST files.
+
+## 0.4.3 - 8-Jun-2020
 * Fixed a bug with ELOOP handling. Thanks go to joast for the spot and fix.
 
-== 0.4.2 - 6-May-2020
+## 0.4.2 - 6-May-2020
 * Added LICENSE file as required by the Apache-2.0 license.
 
-== 0.4.1 - 23-Jan-2019
+## 0.4.1 - 23-Jan-2019
 * Added metadata to the gemspec.
 
-== 0.4.0 - 26-Dec-2018
+## 0.4.0 - 26-Dec-2018
 * License changed to Apache-2.0.
 * Fixed a bug where mindepth and maxdepth would break if more than one
   path was specified as part of the rule. Thanks go to flagos for the spot.
 * The VERSION constant is now frozen.
 * The cert has been updated.
 
-== 0.3.9 - 16-Dec-2015
+## 0.3.9 - 16-Dec-2015
 * This gem is now signed.
 * Added a file-find.rb file for convenience.
 * Updates to the Rakefile and gemspec.
 
-== 0.3.8 - 12-Feb-2014
+## 0.3.8 - 12-Feb-2014
 * Removed all references to the Etc module since the sys-admin library now uses
   FFI and works with JRuby.
 * The :user, :group, and :inum options will now work on MS Windows if you have
@@ -29,27 +40,27 @@
 * Some tests that were previously omitted on Windows are now included.
 * Updates to the test suite, readme, etc.
 
-== 0.3.7 - 15-Jan-2014
+## 0.3.7 - 15-Jan-2014
 * Fixed a bug with brackets in the path name. Thanks go to Jeremy Lawler
   for the spot and the patch.
 
-== 0.3.6 - 6-Sep-2013
+## 0.3.6 - 6-Sep-2013
 * Removed rbconfig from library and test file. Just use File::ALT_SEPARATOR
   to check for Windows instead.
 * Removed unused variables.
 * Updated dev dependencies.
 
-== 0.3.5 - 15-Jul-2011
+## 0.3.5 - 15-Jul-2011
 * Fixed a bug with the :follow option.
 * Gemspec, Rakefile and test cleanup.
 
-== 0.3.4 - 19-Sep-2009
+## 0.3.4 - 19-Sep-2009
 * Fixed a packaging bug. Thanks go to Gabriel Horner for the spot.
 * Added the 'gem' task to the Rakefile for building the gem. Removed the
   gem builder code that was in the gemspec itself.
 * Updated the dependency for sys-admin to 1.5.2.
 
-== 0.3.3 - 3-Aug-2009
+## 0.3.3 - 3-Aug-2009
 * Now compatible with Ruby 1.9.x.
 * Added support for the :links option
 * Updated the :mount accessor to work properly if the value is changed
@@ -58,35 +69,35 @@
 * Added a fuller description to the gemspec.
 * Minor test refactoring.
 
-== 0.3.2 - 20-Feb-2009
+## 0.3.2 - 20-Feb-2009
 * Added support for the :mount option.
 * Added some basic tests for the :mount option.
 
-== 0.3.1 - 9-Jan-2009
+## 0.3.1 - 9-Jan-2009
 * Now defaults to using Etc instead of Sys::Admin for implementations
   that don't support building C extensions, e.g. JRuby.
 * Updated the test suite to work with JRuby.
 * Minor optimizations for symbolic perms and atime/ctime/mtime checks.
   Thanks go in part to Ryan Davis' flay library.
 
-== 0.3.0 - 30-Dec-2008
+## 0.3.0 - 30-Dec-2008
 * Added support for FileTest operations. All options passed to the constructor
   that end with '?' are now validated and treated as FileTest operations.
 
-== 0.2.5 - 29-Dec-2008
+## 0.2.5 - 29-Dec-2008
 * Added maxdepth and mindepth support.
 * Added a 'clean' rake task to cleanup any test-unit results files.
 
-== 0.2.4 - 10-Dec-2008
+## 0.2.4 - 10-Dec-2008
 * Added support for symbolic permissions. Thanks go to Bill Kleb for the
   suggestion and to Hal Fulton for providing the solution.
 
-== 0.2.3 - 25-Nov-2008
+## 0.2.3 - 25-Nov-2008
 * Added mtime support. My previous concerns, which I believe stemmed from
   the find(2) man page on Solaris 10 with regards to atime checks modifying
   the mtime, appear have been unfounded.
 
-== 0.2.2 - 19-Nov-2008
+## 0.2.2 - 19-Nov-2008
 * The :user and :group options now accept a name or a numeric id. Thanks go
   to Bill Kleb for the suggestion.
 * Fixed yet another path bug for MS Windows.
@@ -95,23 +106,23 @@
 * Added sys-admin and test-unit as prerequisites.
 * Added tests for the :user and :group options.
 
-== 0.2.1 - 4-Oct-2007
+## 0.2.1 - 4-Oct-2007
 * Added the File::Find#previous method, which lets you see the previous
   match, if any.
 * Path name bug fix for MS Windows.
 * Test suite bug fixes for MS Windows (perm test now skipped).
 * Inaccessible directories are now skipped instead of raising an error.
 
-== 0.2.0 - 26-Apr-2007
+## 0.2.0 - 26-Apr-2007
 * Fixed a bug where it was not traversing subdirectories.
 * Added support for the perm and prune options.
 
-== 0.1.1 - 25-Apr-2007
+## 0.1.1 - 25-Apr-2007
 * The default for name is now '*', i.e. everything.
 * Fixed a bug where directories were not matched. Thanks go to Leslie Viljoen
   for the spot.
 * The size option now accepts strings with comparable operators. For example,
   you can now look for files greater than 400 bytes with the string "> 400".
 
-== 0.1.0 - 24-Apr-2007
+## 0.1.0 - 24-Apr-2007
 * Initial release

data/Gemfile

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

data/{MANIFEST.rdoc → MANIFEST.md}

@@ -1,6 +1,7 @@
-* CHANGES
-* LICENSE
-* MANIFEST
+* CHANGES.md
+* Gemfile
+* LICENSE.md
+* MANIFEST.md
 * Rakefile
 * README
 * file-find.gemspec

data/{README.rdoc → README.md}

@@ -1,15 +1,15 @@
-= Description
+## Description
 
 This is a drop-in replacement for the find module currently in the standard
 library. It is modeled on a typical 'find' command found on most Unix systems.
 
-= Installation
+## Installation
 
-gem install file-find
+`gem install file-find`
 
-= Synopsis
-
-  require 'file/find'
+## Synopsis
+```ruby
+  require 'file/find' # 'file-find' also works
 
   rule = File::Find.new(
     :pattern => "*.rb",
@@ -20,15 +20,16 @@ gem install file-find
   rule.find{ |f|
     puts f
   }
+```
 
-= Rationale
+## Rationale
 
 The current find module in the standard library is inadequate. It is, quite
 frankly, not much more than a plain Dir.glob call. This library provides an
 interface based on options typically available on your command line 'find'
 command, thus allowing you much greater control over how you find your files.
 
-= Options
+## Options
 
 * atime
 * ctime
@@ -47,18 +48,18 @@ command, thus allowing you much greater control over how you find your files.
 * size
 * user (name or id)
 
-In addition to the above options, FileTest methods such as 'readable?' and
-'writable?' may be used as keys, with true or false for their values.
+In addition to the above options, `FileTest` methods such as `readable?` and
+`writable?` may be used as keys, with true or false for their values.
 
-See the RDoc documentation for more details about these options.
+See the documentation for more details about these options.
 
-= Future Plans
+## Future Plans
 
 None at this time. Please log any feature requests on the project page at:
 
 http://github.com/djberg96/file-find
 
-= Options I won't support
+## Options I won't support
 
 Generally speaking, anything that would require mucking around with C code
 or is just too difficult to implement in a cross platform manner will not be
@@ -74,35 +75,35 @@ supported. These include the following options:
 
 * ok - This is not interactive software.
 
-= Known Issues
+## Known Issues
 
-The :perm option is limited to 0644 and 0444 on MS Windows.
+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, it is not officially a dependency.
+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.
 
-= Bugs
+## Bugs
 
 None that I'm aware of beyond the ones mentioned in the Known Issues. Please
 log any bug reports on the project page at:
 
 http://github.com/djberg96/file-find
 
-= Acknowledgements
+## Acknowledgements
 
 * Richard Clamp's File::Find::Rule Perl module for additional ideas and
   inspiration.
 * Bill Kleb for ideas regarding name, group and perm enhancements.
 * Hal Fulton for his implementation of symbolic permissions.
 
-= License
+## License
 
 Apache-2.0
 
-= Copyright
+## Copyright
 
-(C) 2007-2020, Daniel J. Berger, All Rights Reserved
+(C) 2007-2021, Daniel J. Berger, All Rights Reserved
 
-= Author
+## Author
 
 Daniel J. Berger

data/Rakefile

@@ -1,6 +1,6 @@
 require 'rake'
 require 'rake/clean'
-require 'rake/testtask'
+require 'rspec/core/rake_task'
 
 CLEAN.include("**/*.gem", "**/*.rbc", "**/link*")
 
@@ -21,10 +21,8 @@ namespace :gem do
   end
 end
 
-Rake::TestTask.new do |t|
-  task :test => 'clean'
-  t.warning = true
-  t.verbose = true
+RSpec::Core::RakeTask.new(:spec) do |t|
+  t.pattern = ['spec/file_find_spec.rb']
 end
 
-task :default => :test
+task :default => :spec

data/file-find.gemspec

@@ -2,29 +2,28 @@ require 'rubygems'
 
 Gem::Specification.new do |spec|
   spec.name       = 'file-find'
-  spec.version    = '0.4.4'
+  spec.version    = '0.5.0'
   spec.author     = 'Daniel Berger'
   spec.license    = 'Apache-2.0'
   spec.summary    = 'A better way to find files'
   spec.email      = 'djberg96@gmail.com'
   spec.homepage   = 'http://github.com/djberg96/file-find'
-  spec.test_file  = 'test/test_file_find.rb'
+  spec.test_file  = 'spec/file_find_spec.rb'
   spec.files      = Dir['**/*'].reject{ |f| f.include?('git') }
   spec.cert_chain = Dir['certs/*']
 
-  spec.extra_rdoc_files  = ['README.rdoc', 'CHANGES.rdoc', 'MANIFEST.rdoc']
-
   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',
+    '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'
   }
 
-  spec.add_dependency('sys-admin', '>= 1.6.0')
-  spec.add_development_dependency('test-unit')
+  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('rake')
 
   spec.description = <<-EOF

data/lib/file/find.rb

@@ -9,7 +9,7 @@ end
 
 class File::Find
   # The version of the file-find library
-  VERSION = '0.4.4'.freeze
+  VERSION = '0.5.0'.freeze
 
   # :stopdoc:
   VALID_OPTIONS = %w[
@@ -241,8 +241,9 @@ class File::Find
             end
           end
 
-          # We need to escape any brackets in the directory name.
-          glob = File.join(File.dirname(file).gsub(/([\[\]])/,'\\\\\1'), @name)
+          # We need to escape any brackets in the directory name, unless already escaped.
+          temp = File.dirname(file).gsub(/(?<!\\)([\[\]])/, '\\\\\1')
+          glob = File.join(temp, @name)
 
           # Dir[] doesn't like backslashes
           if File::ALT_SEPARATOR
@@ -259,7 +260,7 @@ class File::Find
           end
 
           if @maxdepth || @mindepth
-            file_depth = file.split(File::SEPARATOR).length
+            file_depth = file.split(File::SEPARATOR).reject{ |e| e.size.zero? }.length
             current_base_path = [@path].flatten.find{ |tpath| file.include?(tpath) }
             path_depth = current_base_path.split(File::SEPARATOR).length
 

data/spec/file_find_spec.rb

@@ -0,0 +1,613 @@
+######################################################################
+# file_find_spec.rb
+#
+# Test case for the file-find library. You should run this via the
+# 'rake spec' task.
+######################################################################
+require 'rspec'
+require 'file-find'
+require 'sys-admin'
+require 'pp' # stops fakefs class mismatch errors
+require 'tmpdir'
+require 'fakefs/spec_helpers'
+
+RSpec.describe File::Find do
+  include FakeFS::SpecHelpers
+
+  let(:windows)    { File::ALT_SEPARATOR }
+  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') }
+
+  before(:all) do
+    @loguser = Sys::Admin.get_user(Sys::Admin.get_login)
+    @logroup = Sys::Admin.get_group(@loguser.gid)
+  end
+
+  context "constants", :constants => true do
+    example "version constant is set to expected value" do
+      expect(File::Find::VERSION).to eq('0.5.0')
+      expect(File::Find::VERSION).to be_frozen
+    end
+  end
+
+  context "path", :path => true 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
+      expect(rule.path).to eq(Dir.pwd)
+    end
+  end
+
+  context "options", :options => true 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
+      expect(txt_rule.options).to eq({:name => '*.txt'})
+    end
+  end
+
+  context "atime", :atime => true do
+    before do
+      FileUtils.touch(ruby_file)
+    end
+
+    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
+      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)
+
+      expect(rule1.find.empty?).to be false
+      expect(rule2.find.empty?).to be true
+    end
+  end
+
+  context "ctime", :ctime => true do
+    before do
+      FileUtils.touch(ruby_file)
+    end
+
+    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
+      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)
+
+      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
+      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)
+      expect(rule.find{}).to be_nil
+    end
+  end
+
+  context "filetest", :filetest => true do
+    before do
+      FileUtils.touch(doc_file, :mode => 0644)
+    end
+
+    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)
+    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
+    end
+
+    example "find method works with filetest option" do
+      rule = File::Find.new(:name => "*.doc", :writable? => true)
+
+      expect(rule.find.map{ |f| File.basename(f) }).to eq([doc_file])
+      FileUtils.chmod(0444, doc_file)
+      expect(rule.find).to eq([])
+    end
+  end
+
+  context "mtime", :mtime => true do
+    before do
+      FileUtils.touch(ruby_file)
+    end
+
+    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
+      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)
+
+      expect(rule1.find.empty?).to be false
+      expect(rule2.find.empty?).to be true
+    end
+  end
+
+  context "ftype", :ftype => true do
+    before do
+      FileUtils.touch(ruby_file)
+    end
+
+    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
+      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")
+
+      expect(rule1.find.empty?).to be false
+      expect(rule2.find.empty?).to be true
+    end
+  end
+
+  context "group", :group => true do
+    before do
+      FileUtils.touch(doc_file)
+    end
+
+    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
+      expect(rule.group).to be_nil
+    end
+
+    # TODO: Update example for Windows
+    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)
+      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
+      skip 'group example skipped on MS Windows' if windows
+
+      rule = File::Find.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
+      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)
+      expect(rule1.find).to eq([])
+      expect(rule2.find).to eq([])
+    end
+  end
+
+  context "inum", :inum => true 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
+      expect(rule.inum).to be_nil
+    end
+  end
+
+  context "follow", :follow => true 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
+      expect(rule.follow).to be true
+    end
+  end
+
+  context "links", :links => true do
+    before do
+      FileUtils.touch(ruby_file)
+      FileUtils.touch(doc_file)
+    end
+
+    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
+      expect(rule.links).to be_nil
+    end
+
+    example "links method returns expected result" do
+      # skip if @@windows && !@@elevated # TODO: Update
+
+      rule1 = File::Find.new(:name => '*.rb', :links => 2)
+      rule2 = File::Find.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
+    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
+      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_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
+
+      expect(file_results).to match_array(bracket_files)
+      expect(dir_results).to match_array(bracket_paths)
+    end
+  end
+
+  context "maxdepth", :maxdepth => true do
+    before do
+      fs = FakeFS::FileSystem.add('a1/a2/a3')
+      rule.pattern = "*.foo"
+
+      FileUtils.touch('a1/a.foo')
+      FileUtils.touch('a1/a2/b.foo')
+      FileUtils.touch('a1/a2/c.foo')
+      FileUtils.touch('a1/a2/a3/d.foo')
+      FileUtils.touch('a1/a2/a3/e.foo')
+      FileUtils.touch('a1/a2/a3/f.foo')
+    end
+
+    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
+      rule.maxdepth = 1
+
+      expect(rule.find).to eq([])
+
+      rule.maxdepth = 2
+      expect(rule.find.map{ |e| File.basename(e) }).to eq(['a.foo'])
+
+      rule.maxdepth = 3
+      expect(rule.find.map{ |e| File.basename(e) }).to match_array(['a.foo', 'b.foo', 'c.foo'])
+    end
+
+    example "find with nil maxdepth option returns everything" do
+      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"
+
+      rule.maxdepth = 1
+      expect(rule.find).to eq([])
+
+      rule.maxdepth = 2
+      expect(rule.find).to eq([])
+
+      rule.maxdepth = 3
+      expect(rule.find.map{ |e| File.basename(e) }).to eq(['a3'])
+    end
+  end
+
+  context "mindepth", :mindepth => true do
+    before do
+      fs = FakeFS::FileSystem.add('a1/a2/a3')
+      rule.pattern = "*.min"
+
+      FileUtils.touch('z.min')
+      FileUtils.touch('a1/a.min')
+      FileUtils.touch('a1/a2/b.min')
+      FileUtils.touch('a1/a2/c.min')
+      FileUtils.touch('a1/a2/a3/d.min')
+      FileUtils.touch('a1/a2/a3/e.min')
+      FileUtils.touch('a1/a2/a3/f.min')
+    end
+
+    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
+      expect(rule.mindepth).to be_nil
+    end
+
+    example "find with mindepth option returns expected results at depth 0" do
+      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
+      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
+      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
+      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
+      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
+      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
+      rule.pattern = 'a1'
+      rule.mindepth = 1
+
+      expect(rule.find.map{ |e| File.basename(e) }).to eq(['a1'])
+
+      rule.mindepth = 2
+      expect(rule.find).to eq([])
+
+      rule.mindepth = 3
+      expect(rule.find).to eq([])
+    end
+  end
+
+  context "mount", :mount => true 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
+      expect(rule.mount).to be_nil
+    end
+  end
+
+  context "name", :name => true 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
+      expect(txt_rule.name).to eq('*.txt')
+    end
+
+    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
+    before do
+      FileUtils.touch(ruby_file)
+      FileUtils.touch(text_file1)
+      FileUtils.touch(text_file2)
+      File.chmod(0464, ruby_file)
+      File.chmod(0644, text_file1)
+      File.chmod(0644, text_file2)
+    end
+
+    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
+      expect(rule.perm).to be_nil
+    end
+
+    example "perm method returns expected results" do
+      results = File::Find.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
+      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
+
+      expect(results1.length).to eq(1)
+      expect(results2.length).to eq(2)
+      expect(File.basename(results1.first)).to eq(ruby_file)
+      expect(results2.map{ |e| File.basename(e) }.sort).to eq([text_file1, text_file2])
+    end
+  end
+
+  context "prune", :prune => true do
+    before do
+      FileUtils.touch(text_file1)
+    end
+
+    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
+      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)
+    end
+  end
+
+  context "size", :size => true 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
+      expect(rule.size).to be_nil
+    end
+  end
+
+  context "user", :user => true do
+    before do
+      FileUtils.touch(doc_file)
+    end
+
+    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
+      expect(rule.user).to be_nil
+    end
+
+    example "user method works with numeric id as expected" do
+      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)
+      expect(rule.find).to eq([File.expand_path(doc_file)])
+    end
+
+    example "user method works with string as expected" do
+      skip if windows && elevated
+      rule = File::Find.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)
+      expect(rule1.find).to eq([])
+      expect(rule2.find).to eq([])
+    end
+  end
+
+  context "previous", :previous => true 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)
+  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)
+  end
+
+  context "eloop", :eloop => true do
+    # Have to disable fakefs for this test because of bug: https://github.com/fakefs/fakefs/issues/459
+    before do
+      FakeFS.deactivate!
+    end
+
+    # TODO: Update example for Windows
+    example 'eloop handling works as expected' do
+      skip 'eloop handling example skipped on MS Windows' if windows
+
+      Dir.chdir(Dir.mktmpdir) do
+        File.symlink('eloop0', 'eloop1')
+        File.symlink('eloop1', 'eloop0')
+        expected = ['./eloop0', './eloop1']
+
+        results = File::Find.new(:path => '.', :follow => true).find
+        expect(results.sort).to eq(expected)
+      end
+    end
+
+    after do
+      FakeFS.activate!
+    end
+  end
+end