file-find 0.1.0

data/CHANGES

@@ -0,0 +1,2 @@
+== 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/tc_find.rb

data/README

@@ -0,0 +1,64 @@
+= 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(
+      :name    => "*.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 package 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 package 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
+* group
+* name
+* path
+* size
+* user
+
+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:
+
+* Support for limiting depth.
+* Greater flexibility with the size option (and perhaps others).
+
+= Bugs
+None that I'm aware of. Please log any bug reports on the project page at
+http://www.rubyforge.org/projects/shards.
+
+= License
+Ruby's
+
+= Copyright
+(C) 2007, Daniel J. Berger, All Rights Reserved
+
+= Author
+Daniel J. Berger

data/lib/file/find.rb

@@ -0,0 +1,206 @@
+require 'date'
+
+class File::Find
+   # The version of this package
+   VERSION = '0.1.0'
+
+   # :stopdoc:
+   VALID_OPTIONS = %w/
+      atime
+      ctime
+      follow
+      ftype
+      inum
+      group
+      name
+      path
+      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. Note that the File::Find#find method itself alters the access
+   # times.
+   #
+   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 ID.
+   #
+   attr_accessor :group
+
+   # Controls the behavior of how symlinks are followed. If set to true, 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
+
+   # The name pattern used to limit file searches. The patterns that are legal
+   # for Dir.glob are legal here.
+   #
+   attr_accessor :name
+
+   # Limits searches to files that match the size, in bytes.
+   #
+   attr_accessor :size
+
+   # Limits searches to files that belong to a specific user ID.
+   #
+   attr_accessor :user
+
+   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.
+   #
+   def initialize(options = {})
+      @options = options      
+
+      @atime  = nil
+      @ctime  = nil
+      @ftype  = nil
+      @group  = nil
+      @follow = true
+      @inum   = nil
+      @name   = nil
+      @size   = nil
+      @user   = nil
+
+      validate_and_set_options(options) unless options.empty?
+
+      @path ||= Dir.pwd
+   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.
+   #
+   def find
+      results = [] unless block_given?
+      paths   = [@path]
+
+      catch(:loop) do
+         paths.each{ |path|
+            Dir.foreach(path){ |file|
+               next if file == '.'
+               next if file == '..'
+
+               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
+               end
+
+               # Add directories back onto the list of paths to search unless
+               # they've already been added.
+               #
+               # TODO: Add depth handling.
+               if stat_info.directory?
+                  unless paths.include?(file)
+                     paths << file
+                     next
+                  end
+               end
+
+               if @atime
+                  date1 = Date.parse(Time.now.to_s)
+                  date2 = Date.parse(stat_info.atime.to_s)
+                  next unless (date1 - date2).numerator == @atime
+               end
+
+               if @ctime
+                  date1 = Date.parse(Time.now.to_s)
+                  date2 = Date.parse(stat_info.ctime.to_s)
+                  next unless (date1 - date2).numerator == @ctime
+               end
+
+               if @ftype
+                  next unless File.ftype(file) == @ftype
+               end
+
+               if @group
+                  next unless stat_info.gid == @group
+               end
+
+               unless RUBY_PLATFORM.match('mswin')
+                  if @inum
+                     next unless stat_info.ino == @inum
+                  end
+               end
+
+               if @name
+                  glob = File.join(File.dirname(file), @name) 
+                  next unless Dir[glob].include?(file)
+               end
+
+               # TODO: Allow more flexible syntax here, e.g. "> 1024".
+               if @size
+                  next unless stat_info.size == @size
+               end
+
+               if @user
+                  next unless stat_info.uid == @user
+               end
+
+               if block_given?
+                  yield file
+               else
+                  results << file
+               end
+            }
+         }
+      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.
+   #
+   def validate_and_set_options(options)
+      options.each do |key, value|
+         key = key.to_s.downcase
+         unless VALID_OPTIONS.include?(key)
+            raise ArgumentError, "invalid option '#{key}'"
+         end
+         send("#{key}=", value)
+      end
+   end
+end

data/test/tc_find.rb

@@ -0,0 +1,125 @@
+######################################################################
+# tc_find.rb
+#
+# Test case for the File::Find package.
+######################################################################
+Dir.chdir '..' if File.basename(Dir.pwd) == 'test'
+$:.unshift File.join(Dir.pwd, 'lib')
+
+require 'test/unit'
+require 'fileutils'
+require 'file/find'
+
+class TC_File_Find < Test::Unit::TestCase
+   def setup
+      @file1 = 'test1.rb'
+      @file2 = 'test1.txt'
+      @link1 = 'link1'
+
+      File.open(@file1, 'w'){}
+      File.open(@file2, 'w'){}
+      File.symlink(@file1, @link1)
+
+      @rule1 = File::Find.new(:name => '*.rb')
+   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 => '*.rb'}, @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_equal(false, rule1.find.empty?)
+      assert_equal(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_equal(false, rule1.find.empty?)
+      assert_equal(true, rule2.find.empty?)
+   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_equal(false, rule1.find.empty?)
+      assert_equal(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_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_equal(true, @rule1.follow)
+   end
+
+   def test_name_basic
+      assert_respond_to(@rule1, :name)
+      assert_respond_to(@rule1, :name=)
+      assert_equal('*.rb', @rule1.name)
+   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_expected_errors
+      assert_raises(Errno::ENOENT){ File::Find.new(:path => '/bogus/dir').find }
+   end
+
+   def teardown
+      FileUtils.rm_rf(@file1)
+      FileUtils.rm_rf(@file2)
+      FileUtils.rm_rf(@link1)
+   end
+end

metadata

@@ -0,0 +1,53 @@
+--- !ruby/object:Gem::Specification 
+rubygems_version: 0.9.2
+specification_version: 1
+name: file-find
+version: !ruby/object:Gem::Version 
+  version: 0.1.0
+date: 2007-04-24 00:00:00 -06:00
+summary: A better way to find files
+require_paths: 
+- lib
+email: djberg96@gmail.com
+homepage: http://www.rubyforge.org/projects/shards
+rubyforge_project: 
+description: A better way to find files
+autorequire: 
+default_executable: 
+bindir: bin
+has_rdoc: true
+required_ruby_version: !ruby/object:Gem::Version::Requirement 
+  requirements: 
+  - - ">"
+    - !ruby/object:Gem::Version 
+      version: 0.0.0
+  version: 
+platform: ruby
+signing_key: 
+cert_chain: 
+post_install_message: 
+authors: 
+- Daniel Berger
+files: 
+- lib/file
+- lib/file/find.rb
+- test/tc_find.rb
+- README
+- CHANGES
+- MANIFEST
+test_files: 
+- test/tc_find.rb
+rdoc_options: []
+
+extra_rdoc_files: 
+- README
+- CHANGES
+- MANIFEST
+executables: []
+
+extensions: []
+
+requirements: []
+
+dependencies: []
+