file-find 0.3.1-universal-java-1.5

data/CHANGES

@@ -0,0 +1,53 @@
+== 0.3.1 - 9-Jan-2008
+* 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
+* 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
+* Added maxdepth and mindepth support.
+* Added a 'clean' rake task to cleanup any test-unit results files.
+
+== 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
+* 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
+* 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.
+* Updated platform check to use CONFIG instead of RUBY_PLATFORM, because the
+  latter does not work as I intended with other implementations, e.g. JRuby.
+* Added sys-admin and test-unit as prerequisites.
+* Added tests for the :user and :group options.
+
+== 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
+* Fixed a bug where it was not traversing subdirectories.
+* Added support for the perm and prune options.
+
+== 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
+* Initial release

data/MANIFEST

@@ -0,0 +1,7 @@
+* CHANGES
+* MANIFEST
+* Rakefile
+* README
+* file-find.gemspec
+* lib/file/find.rb
+* test/test_file_find.rb

data/README

@@ -0,0 +1,111 @@
+= 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.
+
+= Synopsis
+   rule = File::Find.new(
+      :pattern => "*.rb",
+      :follow  => false,
+      :path    => ['/usr/local/lib', '/opt/local/lib']
+   )
+
+   rule.find{ |f|
+      puts f
+   }
+
+= Installation
+* rake test (optional)
+* rake install (non-gem) -OR- rake install_gem (gem)
+
+= 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.
+
+I am aware of the find2 library by Motoyuki Kasahara, but it supports very
+few options, hasn't been updated in over six years and isn't packaged properly.
+
+= Options
+* atime
+* ctime
+* follow
+* ftype
+* inum (except Windows)
+* group (name or id)
+* maxdepth
+* mindepth
+* mtime
+* name (or 'pattern')
+* path
+* perm (except Windows)
+* prune
+* 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.
+
+See the RDoc documentation for more details about these options.
+
+= Future Plans
+More options will be added as time permits, and requests will definitely be
+considered. Please log any feature requests on the project page at
+http://www.rubyforge.org/projects/shards.
+
+Some specific things I plan on adding:
+
+* exec
+* links
+* support for :user and :group on MS Windows
+
+= 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
+supported. These include the following options:
+
+* acl/xattr - Way too difficult to implement in a cross platform manner, and
+  a rarely used option in practice.
+
+* cpio/ncpio - I will not shell out to this or any other 3rd party application.
+
+* ls/print - Use Ruby's builtin printing methods to print as you see fit.
+
+* ok - This is not interactive software.
+
+= Options I may or may not support
+
+* local/mount/xdev - This will probably not be added until I'm satisfied with
+  the sys-filesystem library. As of sys-filesystem 0.1.x, I'm not.
+  
+= Known Issues
+The 'perm' option does not work on MS Windows, even for its limited subset of
+permissions, i.e. 664 and 666. This is arguably a bug in Ruby's
+File::Stat.mode method on MS Windows.
+
+The 'user' and 'group' options are not currently supported on MS Windows.
+This can be supported, but will require changes in the win32-file and
+win32-file-stat libraries (which would then become dependencies).
+
+There are 3 test failures with JRuby, all related to the 'perm' option. I
+have not been able to reduce them to a simple test case and discern the
+exact cause of the failures, though I suspect a bug in the JRuby
+implementation of File.chmod.
+
+= Bugs
+None that I'm aware of. Please log any bug reports on the project page at
+http://www.rubyforge.org/projects/shards.
+
+= Acknowledgements
+* Richard Clamp's File::Find::Rule Perl module for additional ideas and
+  inspiration.
+* Bill Kleb for ideas regarding name, group and perm enhancements.
+
+= License
+Ruby's
+
+= Copyright
+(C) 2007-2008, Daniel J. Berger, All Rights Reserved
+
+= Author
+Daniel J. Berger

data/lib/file/find.rb

@@ -0,0 +1,474 @@
+require 'date'
+require 'rbconfig'
+
+# For alternate implementations of Ruby, such as JRuby, that cannot
+# build C extensions fall back to the Etc module.
+begin
+   require 'sys/admin'
+rescue LoadError
+   require 'etc'
+end
+
+class File::Find
+   # The version of this library
+   VERSION = '0.3.1'
+
+   # :stopdoc:
+   VALID_OPTIONS = %w/
+      atime
+      ctime
+      follow
+      ftype
+      inum
+      group
+      maxdepth
+      mindepth
+      mtime
+      name
+      pattern
+      path
+      perm
+      prune
+      size
+      user
+   /
+   # :startdoc:
+
+   # The starting path(s) for the search. The default is the current directory.
+   # This can be a single path or an array of paths.
+   #
+   attr_accessor :path
+
+   # The list of options passed to the constructor and/or used by the
+   # File::Find#find method.
+   #
+   attr_accessor :options
+
+   # Limits searches by file access time, where the value you supply is the
+   # number of days back from the time that the File::Find#find method was
+   # called.
+   #
+   attr_accessor :atime
+
+   # Limits searches by file change time, where the value you supply is the
+   # number of days back from the time that the File::Find#find method was
+   # called.
+   #
+   attr_accessor :ctime
+
+   # Limits searches to files that belong to a specific group, where the
+   # group can be either a group name or ID.
+   #
+   # Not currently supported on MS Windows.
+   #
+   attr_accessor :group
+
+   # An array of two element arrays for storing FileTest methods and their
+   # boolean value.
+   #
+   attr_accessor :filetest
+
+   # Controls the behavior of how symlinks are followed. If set to true (the
+   # default), then follows the file pointed to. If false, it considers the
+   # symlink itself.
+   #
+   attr_accessor :follow
+
+   # Limits searches to specific types of files. The possible values here are
+   # those returned by the File.ftype method.
+   #
+   attr_accessor :ftype
+
+   # Limits search to a file with a specific inode number. Ignored on MS
+   # Windows.
+   #
+   attr_accessor :inum
+
+   # Limits search to a maximum depth into the tree relative to the starting
+   # search directory.
+   #
+   attr_accessor :maxdepth
+
+   # Limits search to a minimum depth into the tree relative to the starting
+   # search directory.
+   #
+   attr_accessor :mindepth
+
+   # Limits searches by file modification time, where the value you supply is
+   # the number of days back from the time that the File::Find#find method was
+   # called.
+   #
+   attr_accessor :mtime
+
+   # The name pattern used to limit file searches. The patterns that are legal
+   # for Dir.glob are legal here. The default is '*', i.e. everything.
+   #
+   attr_accessor :name
+
+   # Limits searches to files which have permissions that match the octal
+   # value that you provide. For purposes of this comparison, only the user,
+   # group, and world settings are used. Do not use a leading 0 in the values
+   # that you supply, e.g. use 755 not 0755.
+   #
+   # You may optionally use symbolic permissions, e.g. "g+rw", "u=rwx", etc.
+   #
+   # Not currently supported on MS Windows.
+   #
+   attr_accessor :perm
+
+   # Skips files or directories that match the string provided as an argument.
+   #
+   attr_accessor :prune
+
+   # If the value passed is an integer, this option limits searches to files
+   # that match the size, in bytes, exactly. If a string is passed, you can
+   # use the standard comparable operators to match files, e.g. ">= 200" would
+   # limit searches to files greater than or equal to 200 bytes.
+   #
+   attr_accessor :size
+
+   # Limits searches to files that belong to a specific user, where the user
+   # can be either a user name or an ID.
+   #
+   # Not currently supported on MS Windows.
+   #
+   attr_accessor :user
+
+   # The file that matched previously in the current search.
+   #
+   attr_reader :previous
+
+   alias pattern name
+   alias pattern= name=
+
+   # Creates and returns a new File::Find object. The options set for this
+   # object serve as the rules for determining what files the File::Find#find
+   # method will search for.
+   #
+   # In addition to the standard list of valid options, you may also use
+   # FileTest methods as options, setting their value to true or false.
+   #
+   # Example:
+   #
+   #    rule = File::Find.new(
+   #       :name      => "*.rb",
+   #       :follow    => false,
+   #       :path      => ['/usr/local/lib', '/opt/local/lib'],
+   #       :readable? => true
+   #    )
+   #
+   def initialize(options = {})
+      @options = options      
+
+      @atime  = nil
+      @ctime  = nil
+      @ftype  = nil
+      @group  = nil
+      @follow = true
+      @inum   = nil
+      @mtime  = nil
+      @perm   = nil
+      @prune  = nil
+      @size   = nil
+      @user   = nil
+
+      @previous = nil
+      @maxdepth = nil
+      @mindepth = nil
+      @filetest = []
+
+      validate_and_set_options(options) unless options.empty?
+
+      @path ||= Dir.pwd
+      @name ||= '*'
+   end
+
+   # Executes the find based on the rules you set for the File::Find object.
+   # In block form, yields each file in turn that matches the specified rules.
+   # In non-block form it will return an array of matches instead.
+   #
+   # Example:
+   #
+   #   rule = File::Find.new(
+   #      :name    => "*.rb",
+   #      :follow  => false,
+   #      :path    => ['/usr/local/lib', '/opt/local/lib']
+   #   )   
+   #
+   #   rule.find{ |f|
+   #      puts f
+   #   }    
+   #
+   def find
+      results = [] unless block_given?
+      paths   = @path.to_a
+
+      if @prune
+         prune_regex = Regexp.new(@prune)
+      else
+         prune_regex = nil
+      end
+
+      paths.each{ |path|
+         begin
+            Dir.foreach(path){ |file|
+               next if file == '.'
+               next if file == '..'
+
+               if prune_regex
+                  next if prune_regex.match(file)
+               end
+
+               orig = file.dup
+               file = File.join(path, file)
+
+               stat_method = @follow ? :lstat : :stat
+
+               # Skip files we cannot access, stale links, etc.
+               begin
+                  stat_info = File.send(stat_method, file)
+               rescue Errno::ENOENT, Errno::EACCES
+                  next
+               rescue Errno::ELOOP
+                  stat_method = :lstat # Handle recursive symlinks
+                  retry if stat_method.to_s != 'lstat'
+               end
+
+               glob = File.join(File.dirname(file), @name)
+
+               # Dir[] doesn't like backslashes
+               if File::ALT_SEPARATOR
+                  file.tr!(File::ALT_SEPARATOR, File::SEPARATOR) 
+                  glob.tr!(File::ALT_SEPARATOR, File::SEPARATOR) 
+               end
+
+               if @maxdepth || @mindepth
+                  file_depth = file.split(File::SEPARATOR).length
+                  path_depth = @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
+                     end
+
+                     next
+                  end
+
+                  if @mindepth && (depth < @mindepth)
+                     if File.directory?(file)
+                        unless paths.include?(file) && depth < @mindepth
+                           paths << file
+                        end
+                     end
+
+                     next
+                  end
+               end
+
+               # 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)
+               end
+
+               next unless Dir[glob].include?(file)
+
+               unless @filetest.empty?
+                  file_test = true
+
+                  @filetest.each{ |array|
+                     meth = array[0]
+                     bool = array[1]
+
+                     unless File.send(meth, file) == bool
+                        file_test = false
+                        break
+                     end
+                  }
+
+                  next unless file_test
+               end
+
+               if @atime || @ctime || @mtime
+                  date1 = Date.parse(Time.now.to_s)
+
+                  if @atime
+                     date2 = Date.parse(stat_info.atime.to_s)
+                     next unless (date1 - date2).numerator == @atime
+                  end
+
+                  if @ctime
+                     date2 = Date.parse(stat_info.ctime.to_s)
+                     next unless (date1 - date2).numerator == @ctime
+                  end
+
+                  if @mtime
+                     date2 = Date.parse(stat_info.mtime.to_s)
+                     next unless (date1 - date2).numerator == @mtime
+                  end
+               end
+
+               if @ftype
+                  next unless File.ftype(file) == @ftype
+               end
+
+               if @group
+                  if @group.is_a?(String)
+                     next unless get_group(stat_info.gid).name == @group
+                  else
+                     next unless stat_info.gid == @group
+                  end
+               end
+
+               unless Config::CONFIG['host_os'] =~ /windows|mswin/i
+                  if @inum
+                     next unless stat_info.ino == @inum
+                  end
+               end
+
+               # This currently doesn't work on MS Windows, even in limited
+               # fashion for 0666 and 0664, because File.stat.mode doesn't
+               # return the proper value.
+               #
+               if @perm
+                  if @perm.is_a?(String)
+                     octal_perm = sym2oct(@perm)
+                     next unless stat_info.mode & octal_perm == octal_perm
+                  else
+                     next unless sprintf("%o", stat_info.mode & 07777) == @perm.to_s
+                  end
+               end
+
+               # Allow plain numbers, or strings for comparison operators.
+               if @size
+                  if @size.is_a?(String)
+                     regex = /^([><=]+)\s*?(\d+)$/
+                     match = regex.match(@size)
+
+                     if match.nil? || match.captures.include?(nil)
+                        raise ArgumentError, "invalid size string: '#{@size}'"
+                     end
+
+                     operator = match.captures.first.strip
+                     number   = match.captures.last.strip.to_i
+
+                     next unless stat_info.size.send(operator, number)
+                  else
+                     next unless stat_info.size == @size
+                  end
+               end
+
+               if @user
+                  if @user.is_a?(String)
+                     next unless get_user(stat_info.uid).name == @user
+                  else
+                     next unless stat_info.uid == @user
+                  end
+               end
+
+               if block_given?
+                  yield file
+               else
+                  results << file
+               end
+
+               @previous = file unless @previous == file
+            }
+         rescue Errno::EACCES
+            next # Skip inaccessible directories
+         end
+      }
+
+      block_given? ? nil : results
+   end
+
+   private
+
+   # This validates that the keys are valid. If they are, it sets the value
+   # of that key's corresponding method to the given value. If a key ends
+   # with a '?', it's validated as a File method.
+   #
+   def validate_and_set_options(options)
+      options.each do |key, value|
+         key = key.to_s.downcase
+
+         if key[-1].chr == '?'
+            sym = key.to_sym
+
+            unless File.respond_to?(sym)
+               raise ArgumentError, "invalid option '#{key}'"
+            end
+
+            @filetest << [sym, value]
+         else
+            unless VALID_OPTIONS.include?(key)
+               raise ArgumentError, "invalid option '#{key}'"
+            end
+
+            send("#{key}=", value)
+         end
+      end
+   end
+
+   # Converts a symoblic permissions mode into its octal equivalent.
+   #--
+   # Taken almost entirely from ruby-talk: 96956 (Hal Fulton).
+   #
+   def sym2oct(str)
+      left  = {'u' => 0700, 'g' => 0070, 'o' => 0007, 'a' => 0777}
+      right = {'r' => 0444, 'w' => 0222, 'x' => 0111}
+      regex = /([ugoa]+)([+-=])([rwx]+)/
+
+      cmds = str.split(',')
+
+      perm = 0
+
+      cmds.each do |cmd|
+         match = cmd.match(regex)
+         raise "Invalid symbolic permissions: '#{str}'" if match.nil?
+
+         junk, who, what, how = match.to_a
+
+         who = who.split(//).inject(num=0) { |num,b| num |= left[b]; num }
+         how = how.split(//).inject(num=0) { |num,b| num |= right[b]; num }
+         mask = who & how
+
+         case what
+            when '+'
+               perm = perm | mask
+            when '-'
+               perm = perm & ~mask
+            when '='
+               perm = mask
+         end
+      end
+
+      perm
+   end
+
+   # Returns the group object based on the group id. Implemented for the
+   # sake of platforms that cannot build extensions, such as JRuby.
+   #
+   def get_group(gid)
+      if defined? Sys::Admin
+         Sys::Admin.get_group(gid)
+      else
+         Etc.getgrgid(gid)
+      end
+   end
+
+   # Returns the user object based on the group id. Implemented for the
+   # sake of platforms that cannot build extensions, such as JRuby.
+   #
+   def get_user(uid)
+      if defined? Sys::Admin
+         Sys::Admin.get_user(uid)
+      else
+         Etc.getpwuid(uid)
+      end
+   end
+end

data/test/test_file_find.rb

@@ -0,0 +1,431 @@
+######################################################################
+# test_file_find.rb
+#
+# Test case for the File::Find package. You should run this via the
+# 'rake test' task.
+######################################################################
+require 'rubygems'
+gem 'test-unit'
+
+require 'test/unit'
+require 'fileutils'
+require 'file/find'
+require 'rbconfig'
+
+begin
+   require 'sys/admin'
+rescue LoadError
+   require 'etc'
+end
+
+include Config
+include FileUtils
+
+class TC_File_Find < Test::Unit::TestCase
+   def self.startup
+      Dir.chdir('test') unless File.basename(Dir.pwd) == 'test'
+
+      @@windows = CONFIG['host_os'] =~ /windows|mswin/i
+      @@jruby   = RUBY_PLATFORM.match('java')
+
+      unless @@windows
+         if @@jruby
+            @@loguser = Etc.getpwnam(Etc.getlogin)
+            @@logroup = Etc.getgrgid(@@loguser.gid)
+         else
+            @@loguser = Sys::Admin.get_user(Sys::Admin.get_login)
+            @@logroup = Sys::Admin.get_group(@@loguser.gid)
+         end
+      end
+   end
+
+   def setup
+      @file1 = 'test1.rb'
+      @file2 = 'test1.txt'
+      @file3 = 'foo.txt'
+      @file4 = 'foo.doc'
+      @dir1  = 'dir1'
+      @dir2  = 'dir2'
+
+      File.open(@file1, 'w'){}
+      File.open(@file2, 'w'){}
+      File.open(@file3, 'w'){}
+      File.open(@file4, 'w'){}
+
+      unless @@windows
+         @link1 = 'link1'
+         File.symlink(@file1, @link1)
+      end
+
+      Dir.mkdir(@dir1) unless File.exists?(@dir1)
+      Dir.mkdir(@dir2) unless File.exists?(@dir2)
+
+      File.open(File.join(@dir1, 'bar.txt'), 'w'){}
+      File.open(File.join(@dir2, 'baz.txt'), 'w'){}
+
+      @rule1 = File::Find.new(:name => '*.txt')
+      @rule2 = File::Find.new
+   end
+
+   def test_version
+      assert_equal('0.3.1', File::Find::VERSION)
+   end
+
+   def test_path
+      assert_respond_to(@rule1, :path)
+      assert_respond_to(@rule1, :path=)
+      assert_equal(Dir.pwd, @rule1.path)
+   end
+
+   def test_options
+      assert_respond_to(@rule1, :options)
+      assert_respond_to(@rule1, :options=)
+      assert_equal({:name => '*.txt'}, @rule1.options)
+   end
+
+   def test_atime_basic
+      assert_respond_to(@rule1, :atime)
+      assert_respond_to(@rule1, :atime=)
+      assert_nil(@rule1.atime)
+   end
+
+   def test_atime
+      rule1 = File::Find.new(:name => "*.rb", :atime => 0)
+      rule2 = File::Find.new(:name => "*.rb", :atime => 1)
+
+      assert_false(rule1.find.empty?)
+      assert_true(rule2.find.empty?)
+   end
+
+   def test_ctime_basic
+      assert_respond_to(@rule1, :ctime)
+      assert_respond_to(@rule1, :ctime=)
+      assert_nil(@rule1.ctime)
+   end
+
+   def test_ctime
+      rule1 = File::Find.new(:name => "*.rb", :ctime => 0)
+      rule2 = File::Find.new(:name => "*.rb", :ctime => 1)
+
+      assert_false(rule1.find.empty?)
+      assert_true(rule2.find.empty?)
+   end
+
+   def test_find_basic
+      assert_respond_to(@rule1, :find)
+      assert_nothing_raised{ @rule1.find }
+   end
+
+   def test_find
+      assert_kind_of(Array, @rule1.find)
+      assert_nil(@rule1.find{})
+   end
+
+   def test_filetest_basic
+      assert_respond_to(@rule1, :filetest)
+      assert_respond_to(@rule1, :filetest=)
+      assert_nothing_raised{ @rule1.filetest }
+      assert_kind_of(Array, @rule1.filetest)
+   end
+
+   def test_filetest_valid_options
+      assert_nothing_raised{ File::Find.new(:readable? => true) }
+      assert_nothing_raised{ File::Find.new(:writable? => true) }
+   end
+
+   def test_filetest
+      omit_if(@@windows && @@jruby, "Skipping file test on JRuby/Windows")
+
+      rule = File::Find.new(:name => "*.doc", :writable? => true)
+      File.chmod(0644, @file4)
+
+      assert_equal([@file4], rule.find.map{ |f| File.basename(f) })
+
+      File.chmod(0444, @file4)
+
+      assert_equal([], rule.find)
+   end
+
+   def test_mtime
+      rule1 = File::Find.new(:name => "*.rb", :mtime => 0)
+      rule2 = File::Find.new(:name => "*.rb", :mtime => 1)
+
+      assert_false(rule1.find.empty?)
+      assert_true(rule2.find.empty?)
+   end
+
+   def test_mtime_basic
+      assert_respond_to(@rule1, :mtime)
+      assert_respond_to(@rule1, :mtime=)
+      assert_nil(@rule1.mtime)
+   end
+
+   def test_ftype_basic
+      assert_respond_to(@rule1, :ftype)
+      assert_respond_to(@rule1, :ftype=)
+      assert_nil(@rule1.ftype)
+   end
+
+   def test_ftype
+      rule1 = File::Find.new(:name => "*.rb", :ftype => "file")
+      rule2 = File::Find.new(:name => "*.rb", :ftype => "characterSpecial")
+
+      assert_false(rule1.find.empty?)
+      assert_true(rule2.find.empty?)
+   end
+
+   def test_group_basic
+      assert_respond_to(@rule1, :group)
+      assert_respond_to(@rule1, :group=)
+      assert_nil(@rule1.group)
+   end
+
+   def test_group_with_numeric_id
+      omit_if(@@windows, 'group test skipped on MS Windows')
+      @rule1 = File::Find.new(:name => '*.doc', :group => @@loguser.gid)
+      assert_equal([File.expand_path(@file4)], @rule1.find)
+   end
+
+   def test_group_with_string
+      omit_if(@@windows, 'group test skipped on MS Windows')
+      @rule1 = File::Find.new(:name => '*.doc', :group => @@logroup.name)
+      assert_equal([File.expand_path(@file4)], @rule1.find)
+   end
+
+   def test_group_with_bad_id
+      omit_if(@@windows, 'group test skipped on MS Windows')
+      @rule1 = File::Find.new(:name => '*.doc', :group => 'totallybogus')
+      @rule2 = File::Find.new(:name => '*.doc', :group => 99999999)
+      assert_equal([], @rule1.find)
+      assert_equal([], @rule2.find)
+   end
+
+   def test_inum_basic
+      assert_respond_to(@rule1, :inum)
+      assert_respond_to(@rule1, :inum=)
+      assert_nil(@rule1.inum)
+   end
+
+   def test_follow_basic
+      assert_respond_to(@rule1, :follow)
+      assert_respond_to(@rule1, :follow=)
+      assert_true(@rule1.follow)
+   end
+
+   def test_maxdepth_basic
+      assert_respond_to(@rule1, :maxdepth)
+      assert_respond_to(@rule1, :maxdepth=)
+      assert_nil(@rule1.maxdepth)
+   end
+   
+   def test_maxdepth_file
+      mkpath('a1/a2/a3')
+      touch('a1/a.foo')
+      touch('a1/a2/b.foo')
+      touch('a1/a2/c.foo')
+      touch('a1/a2/a3/d.foo')
+      touch('a1/a2/a3/e.foo')
+      touch('a1/a2/a3/f.foo')
+      
+      @rule2.pattern = "*.foo"
+      @rule2.maxdepth = 1    
+      assert_equal([], @rule2.find)
+      
+      @rule2.maxdepth = 2
+      assert_equal(['a.foo'], @rule2.find.map{ |e| File.basename(e) })
+      
+      @rule2.maxdepth = 3
+      assert_equal(['a.foo', 'b.foo', 'c.foo'], @rule2.find.map{ |e| File.basename(e) })
+      
+      @rule2.maxdepth = nil
+      assert_equal(['a.foo', 'b.foo', 'c.foo', 'd.foo', 'e.foo', 'f.foo'], @rule2.find.map{ |e| File.basename(e) })
+   end
+
+   def test_maxdepth_directory
+      mkpath('a/b/c')
+      @rule2.pattern = "c"
+
+      @rule2.maxdepth = 1    
+      assert_equal([], @rule2.find)
+      
+      @rule2.maxdepth = 2
+      assert_equal([], @rule2.find)
+      
+      @rule2.maxdepth = 3
+      assert_equal(['c'], @rule2.find.map{ |e| File.basename(e) })
+   end
+
+   def test_mindepth_basic
+      assert_respond_to(@rule1, :mindepth)
+      assert_respond_to(@rule1, :mindepth=)
+      assert_nil(@rule1.mindepth)
+   end
+
+   def test_mindepth_file
+      mkpath('a1/a2/a3')
+      touch('z.min')
+      touch('a1/a.min')
+      touch('a1/a2/b.min')
+      touch('a1/a2/c.min')
+      touch('a1/a2/a3/d.min')
+      touch('a1/a2/a3/e.min')
+      touch('a1/a2/a3/f.min')
+      
+      @rule2.pattern = "*.min"
+
+      @rule2.mindepth = 0
+      assert_equal(['z.min', 'a.min', 'b.min', 'c.min', 'd.min', 'e.min', 'f.min'], @rule2.find.map{ |e| File.basename(e) })
+
+      @rule2.mindepth = 1
+      assert_equal(['z.min', 'a.min', 'b.min', 'c.min', 'd.min', 'e.min', 'f.min'], @rule2.find.map{ |e| File.basename(e) })
+
+      @rule2.mindepth = 2
+      assert_equal(['a.min', 'b.min', 'c.min', 'd.min', 'e.min', 'f.min'], @rule2.find.map{ |e| File.basename(e) })
+      
+      @rule2.mindepth = 3
+      assert_equal(['b.min', 'c.min', 'd.min', 'e.min', 'f.min'], @rule2.find.map{ |e| File.basename(e) })
+      
+      @rule2.mindepth = 4
+      assert_equal(['d.min', 'e.min', 'f.min'], @rule2.find.map{ |e| File.basename(e) })
+
+      @rule2.mindepth = 5
+      assert_equal([], @rule2.find.map{ |e| File.basename(e) })
+   end
+
+   def test_mindepth_directory
+      mkpath('a/b/c')
+      @rule2.pattern = "a"
+
+      @rule2.mindepth = 1    
+      assert_equal(['a'], @rule2.find.map{ |e| File.basename(e) })
+      
+      @rule2.mindepth = 2
+      assert_equal([], @rule2.find)
+      
+      @rule2.mindepth = 3
+      assert_equal([], @rule2.find)
+   end
+
+   def test_name_basic
+      assert_respond_to(@rule1, :name)
+      assert_respond_to(@rule1, :name=)
+      assert_equal('*.txt', @rule1.name)
+   end
+
+   def test_pattern_alias
+      assert_respond_to(@rule1, :pattern)
+      assert_respond_to(@rule1, :pattern=)
+      assert_true(@rule1.method(:name) == @rule1.method(:pattern))
+      assert_true(@rule1.method(:name=) == @rule1.method(:pattern=))
+   end
+
+   def test_perm_basic
+      assert_respond_to(@rule1, :perm)
+      assert_respond_to(@rule1, :perm=)
+      assert_nil(@rule1.perm)
+   end
+
+   def test_perm
+      omit_if(@@windows, 'perm test skipped on MS Windows')
+      File.chmod(0664, @file1) 
+      File.chmod(0644, @file2) 
+      results = File::Find.new(:name => "test1*", :perm => 664).find
+
+      assert_equal(1, results.length)
+      assert_equal('test1.rb', File.basename(results.first))
+   end
+
+   def test_perm_with_symbolic_permissions
+      omit_if(@@windows, 'symbolic perm test skipped on MS Windows')
+
+      File.chmod(0664, @file1)  # test1.rb
+      File.chmod(0644, @file2)  # test1.txt
+      results1 = File::Find.new(:name => "test1*", :perm => "g=rw").find
+      results2 = File::Find.new(:name => "test1*", :perm => "u=rw").find
+
+      assert_equal(1, results1.length)
+      assert_equal(2, results2.length)
+      assert_equal('test1.rb', File.basename(results1.first))
+      assert_equal(['test1.rb', 'test1.txt'], results2.map{ |e| File.basename(e) })
+   end
+
+   def test_prune_basic
+      assert_respond_to(@rule1, :prune)
+      assert_respond_to(@rule1, :prune=)
+      assert_nil(@rule1.prune)
+   end
+
+   def test_prune
+      rule = File::Find.new(:name => "*.txt", :prune => 'foo')
+      assert_equal('test1.txt', File.basename(rule.find.first))
+   end
+
+   def test_size_basic
+      assert_respond_to(@rule1, :size)
+      assert_respond_to(@rule1, :size=)
+      assert_nil(@rule1.size)
+   end
+
+   def test_user_basic
+      assert_respond_to(@rule1, :user)
+      assert_respond_to(@rule1, :user=)
+      assert_nil(@rule1.user)
+   end
+
+   def test_user_with_numeric_id
+      omit_if(@@windows, 'user test skipped on MS Windows')
+      @rule1 = File::Find.new(:name => '*.doc', :user => @@loguser.uid)
+      assert_equal([File.expand_path(@file4)], @rule1.find)
+   end
+
+   def test_user_with_string
+      omit_if(@@windows, 'user test skipped on MS Windows')
+      @rule1 = File::Find.new(:name => '*.doc', :user => @@loguser.name)
+      assert_equal([File.expand_path(@file4)], @rule1.find)
+   end
+
+   def test_user_with_bad_id
+      omit_if(@@windows, 'user test skipped on MS Windows')
+      @rule1 = File::Find.new(:name => '*.doc', :user => 'totallybogus')
+      @rule2 = File::Find.new(:name => '*.doc', :user => 99999999)
+      assert_equal([], @rule1.find)
+      assert_equal([], @rule2.find)
+   end
+
+   def test_previous_basic
+      assert_respond_to(@rule1, :previous)
+   end
+
+   def test_expected_errors
+      assert_raise(Errno::ENOENT){ File::Find.new(:path => '/bogus/dir').find }
+      assert_raise(ArgumentError){ File::Find.new(:bogus => 1) }
+      assert_raise(ArgumentError){ File::Find.new(:bogus? => true) }
+   end
+
+   def teardown
+      rm_rf(@file1)
+      rm_rf(@file2)
+      rm_rf(@file3)
+      rm_rf(@file4)
+      rm_rf(@dir1)
+      rm_rf(@dir2)
+      rm_rf(@link1) unless @@windows
+      rm_rf('a')
+      rm_rf('a1')
+      rm_rf('z.min') if File.exists?('z.min')
+
+      @rule1 = nil
+      @rule2 = nil
+      @file1 = nil
+      @file2 = nil
+      @file3 = nil
+      @file4 = nil
+   end
+
+   def self.shutdown
+      @@windows = nil
+      @@jruby   = nil
+      @@loguser = nil unless @@windows
+      @@logroup = nil unless @@windows
+   end
+end

metadata

@@ -0,0 +1,69 @@
+--- !ruby/object:Gem::Specification 
+extensions: []
+
+homepage: http://www.rubyforge.org/projects/shards
+executables: []
+
+version: !ruby/object:Gem::Version 
+  version: 0.3.1
+post_install_message: 
+date: 2009-01-09 07:00:00 +00:00
+files: 
+- lib/file
+- lib/file/find.rb
+- test/test_file_find.rb
+- README
+- CHANGES
+- MANIFEST
+rubygems_version: 1.3.1
+rdoc_options: []
+
+signing_key: 
+cert_chain: []
+
+name: file-find
+has_rdoc: true
+platform: universal-java-1.5
+summary: A better way to find files
+default_executable: 
+bindir: bin
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  version: 
+  requirements: 
+  - - '>='
+    - !ruby/object:Gem::Version 
+      version: "0"
+required_ruby_version: !ruby/object:Gem::Requirement 
+  version: 
+  requirements: 
+  - - '>='
+    - !ruby/object:Gem::Version 
+      version: "0"
+require_paths: 
+- lib
+specification_version: 2
+test_files: 
+- test/test_file_find.rb
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  type: :runtime
+  name: test-unit
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    version: 
+    requirements: 
+    - - '>='
+      - !ruby/object:Gem::Version 
+        version: 2.0.2
+description: A better way to find files
+email: djberg96@gmail.com
+authors: 
+- Daniel Berger
+extra_rdoc_files: 
+- README
+- CHANGES
+- MANIFEST
+requirements: []
+
+rubyforge_project: shards
+autorequire: