Module: Cfruby::FileFind

Defined in:

lib/libcfruby/filefind.rb

Defined Under Namespace

Classes: FileExistError, FileFindError, FileMatch

Class Method Summary

• .find(basedir, options = {}, &block) ⇒ Object

  Find files that conform to a set of options within a given base directory and yield them to a given block.

Class Method Details

.find(basedir, options = {}, &block) ⇒ Object

Find files that conform to a set of options within a given base directory and yield them to a given block. In addition to all of the options available to FileMatch the following options may be given:

:depth

the maximum depth to recurse into the base directory

:recursive

recurse (default to a depth => 200)

:nonrecursive

don’t recurse at all (equivilant to :depth => 0)

:followsymlinks

if true symlinks are expanded and returned as their realpath, otherwise they are returned as is (default false)

:returnorder

if unset files are returned in traversal order, if set to ‘delete’ files are returned first followed by directories

:filematch

normally internal use only, allows passing in of a FileMatch object (all other file matching options ignored)

Returns the number of files found

# File 'lib/libcfruby/filefind.rb', line 316

def FileFind.find(basedir, options = {}, &block)
  filematch = nil
  matched = 0

  if(options[:filematch] != nil)
    filematch = options[:filematch]
  else
    # set real options based on helper options
    if((options[:nonrecursive] or options[:recursive]) and options[:depth])
      raise(ArgumentError, ":depth argument is not meaningful with :recursive or :nonrecursive")
    end
    if(options[:nonrecursive])
      options[:depth] = 0
    elsif(options[:recursive])
      options[:depth] = 200 if options[:depth] == nil
      options.delete(:recursive)
    end

    # set basic options if they weren't passed in
    if(options[:glob] == nil)
      Cfruby.controller.inform('debug', "No glob given for search, using '*'")
      options[:glob] = '*'
    end
    if(options[:depth] == nil)
      Cfruby.controller.inform('debug', "No depth given for search, using 0")
      options[:depth] = 0
    end

    # get a filematch object
    filematch = FileMatch.new(options)
  end

  # add the filematch back to options so we can pass it back to
  # ourselves recursively
  options[:filematch] = filematch
  
  # set some options to local variables to prevent a lookup on every file
  maxdepth = options[:depth]

  # set the file return order
  deleteorder = false
  if(options[:returnorder] == 'delete')
    deleteorder = true
  end
  
  # allow people to pass in lists
  if(basedir.respond_to?(:each) and !basedir.kind_of?(String) and !basedir.kind_of?(Pathname))
    basedir.each() { |subdir|
      find(subdir, options) { |filename|
        matched += 1
        yield(filename)
      }
    }
    return(matched)
  else
    # attempt to expand with a glob and expand_path
    dirs = Dir.glob(File.expand_path(basedir.to_s))
    if(dirs.length > 1)
      find(dirs, options) { |filename|
        matched += 1
        yield(filename)
      }
      return(matched)
    elsif(dirs.length == 0)
      # if we didn't get anything out of the glob expansion, then the file doesn't really exist
      raise(FileExistError, "\"#{basedir}\" does not exist")
    else
      basedir = dirs[0]
    end
  end
  
  # convert basedir into an absolute pathname
  if(!basedir.kind_of?(Pathname))
    basedir = Pathname.new(basedir)
  end
  
  if(!basedir.symlink?() and !basedir.exist?())
    raise(FileExistError, "#{basedir.to_s} does not exist")
  end
  
  directories = Array.new()
  visited = Hash.new()
  # if the given basedir is a symlink, only follow it if :followsymlink == true
  if(basedir.symlink? and !options[:followsymlinks])
    if(filematch.matches?(basedir.expand_path))
      matched += 1
      yield(basedir.expand_path)
    end
  else
    basedir = basedir.realpath
    directories << Array.[](basedir, 0)
  end

  yielddirs = Array.new()
  
  while(directories.length > 0)
    currentdir = directories.pop()
    
    # skip this directory if we have already been there
    if(visited[currentdir[0]] != nil)
      next
    else
      visited[currentdir[0]] = true
    end
    
    currentdepth = currentdir[1]
    currentdir = currentdir[0]
    
    # add the directory to the yielddirs list if we need to, or yield it
    # depending on :returnorder
    if(filematch.matches?(currentdir))
      if(deleteorder)
        yielddirs << currentdir
      else
        matched += 1
        yield(currentdir)
      end
    end

    # yield files at this level and recurse if needed.  We use a form of pseudo recursion to avoid
    # exhausting the stack depth.  Directories that match the find are added to a special yielddirs
    # list and are yielded to the caller after the entire recursion has finished.  This ensures that
    # things like recursive delete work properly.
    if(currentdepth < maxdepth)
      Dir.glob("#{currentdir}/*", File::FNM_DOTMATCH) { |filename|
        filename = FileFind.expand_path(Pathname.new(filename), options)

        # skip if it escapes our basedir
        if(filename.relative_path_from(basedir).to_s() =~ /(^|\/)\.\.(\/|$)/)
          next
        end

        # if it is a directory add it to the list for recursion
        if(filename.directory?())
          directories.push(Array.[](filename, currentdepth+1))
        elsif(filematch.matches?(filename))
          Cfruby.controller.inform('debug', "found #{filename}")
          matched += 1
          yield(filename)
        end
      }
    end

  end
  
  while(yielddirs.length > 0)
    matched += 1
    yield(yielddirs.pop)
  end

  return(matched)
end