rant 0.5.0 → 0.5.2

data/doc/homepage/index.html

@@ -105,6 +105,12 @@
             before installing a newer version of Rant. It describes
             non-backwards compatible changes and new features.
             </p>
+            <h2>Rant libraries</h2>
+            <p>
+            You can reuse code written for the Rant build tool as
+            &quot;normal&quot; Ruby library. Read <a
+                href="files/doc/rubylib_rdoc.html">Rant libraries</a>
+            </p>
             <h2>Rant vs. Rake</h2>
             <p>
             <a href="files/doc/rant_vs_rake_rdoc.html">Read comparison</a>
@@ -118,8 +124,8 @@
         <a href="http://developer.berlios.de" title="BerliOS
             Developer"> <img
             src="http://developer.berlios.de/bslogo.php?group_id=5046"
-            width="124px" height="32px" border="0" alt="BerliOS
-            Developer Logo"></a>
+            width="124px" height="32px" alt="BerliOS
+            Developer Logo" /></a>
         </p>
 
         <!-- BlueRobot was here. -->

data/doc/rantfile.rdoc

@@ -209,31 +209,11 @@ explain it a little bit. It can be used in three ways:
 
         file "program" => sys["*.o"]
 
-   The task "program" depends on all files ending in ".o". Rant uses
-   the Dir::glob method internally to resolve patterns, so you can
-   read the ri docs to get an overview:
-
-        ri Dir::glob
-
-   From now on we'll call <tt>sys[...]</tt> the <em>glob
-   operator</em>.
-
-   You can give more patterns:
-
-        c_files = sys["**/*.h", "**/*.c"]
-
-   gives a list of all files ending in ".h" or ".c" in the current
-   directory and all subdirectories.
-
-   The object returned by the glob operator _behaves_ like an array of
-   strings, so it is possible to pass it to methods expecting an array.
-   If you're getting errors or experience strange behaviour convert
-   the list explicetely to an array:
-
-        # method foo_bar is hardcoded to check for an object of class
-        # Array
-        foo_bar(c_files.to_a)
-
+   The task "program" depends on all files ending in ".o".
+    
+   For extensive documentation read 
+   doc/sys_filelist.rdoc[link:files/doc/sys_filelist_rdoc.html].
+   
 === Generators
 
 The *gen* function takes a generator which usually creates one or more
@@ -469,5 +449,7 @@ Packaging::
     doc/package.rdoc[link:files/doc/package_rdoc.html]
 Ruby project howto::
     doc/rubyproject.rdoc[link:files/doc/rubyproject_rdoc.html]
+Using filelists in Rantfiles::
+   doc/sys_filelist.rdoc[link:files/doc/sys_filelist_rdoc.html]
 Rant Overview::
     README[link:files/README.html]

data/doc/rubylib.rdoc

@@ -0,0 +1,27 @@
+
+== Rant libraries
+
+The Rant build tool contains much code that can be reused in other
+Ruby applications or libraries. This document provides an overview of
+what is "officially" supported.
+
+As Rant matures, more classes will be provided to drive Rant
+programmatically or just to allow reuse of library code.
+
+=== Rant::FileList class
+
+This class provides an abstraction over the <tt>Dir.glob</tt> and
+<tt>File.fnmatch</tt> methods. In many cases it can be used instead of
+the +Find+ module in Ruby's standard library.
+
+Read doc/filelist.rdoc[link:files/doc/filelist_rdoc.html] for full
+documentation of the <tt>Rant::FileList</tt> class.
+
+== See also
+
+Rant Homepage::
+    http://make.ruby-co.de
+Rant Overview::
+    README[link:files/README.html]
+Rant::FileList documentation::
+    doc/filelist.rdoc[link:files/doc/filelist_rdoc.html]

data/doc/sys.rdoc

@@ -536,13 +536,26 @@ standard output:
         #   on windows: 'dmd "foo bar.d" util.d -offoo -I"/home/user/program files/d"'
         #   other systems: 'dmd foo\ bar.d util.d -offoo -I/home/user/program\ files/d'
 
+* <b>regular_filename(path)</b>
+
+  Replaces all platform dependent filename separators with a slash,
+  thus returning a platform independent filename.
+
+  Examples:
+
+    # on windows:
+    sys.regular_filename('foo\bar')             # "foo/bar"
+
+    # on all platforms:
+    sys.regular_filename('foo//bar')            # "foo/bar"
+
 * <b>glob(pattern1, pattern2, ...)</b>
 
   <b>[pattern1, pattern2, ...]</b>
 
   Returns a filelist including the given patterns. For a discussion of
-  filelists, read <em>Selecting files with filelists</em> in
-  doc/advanced.rdoc[link:files/doc/advanced_rdoc.html].
+  filelists, read
+  doc/sys_filelist.rdoc[link:files/doc/sys_filelist_rdoc.html].
 
   Examples:
 

data/doc/sys_filelist.rdoc

@@ -0,0 +1,118 @@
+
+== Using filelists in Rantfiles
+
+You can find documentation for Rant's +FileList+ class in the file
+doc/filelist.rdoc[link:files/doc/filelist_rdoc.html]. This document
+describes how you can use filelists in your Rant build scripts
+(Rantfiles).
+
+First of all, you don't need to <tt>require</tt> or <tt>import</tt>
+anything to use filelists in Rantfiles. Additionally the
+<tt>Rant::FileList</tt> class is directly available as +FileList+.
+Thus, for example, instead of typing:
+
+    c_files = Rant::FileList["*.c"]
+
+you can type:
+
+    c_files = FileList["*.c"]
+
+Again, you don't need to <tt>require "rant/filelist"</tt>. But if you
+want to use one of the methods +no_dir+, +files+ or +dirs+ <tt>import
+"filelist/std"</tt> is required.
+
+Often there are files/directories you want to always ignore when using
+filelists. This could be the "CVS" directories if you are using the
+CVS version control system or simply all backup files.
+
+Rant allows you to specify a set of patterns once for your project
+with the <tt>sys.ignore</tt> method.
+
+E.g. place the following line of code in your Rantfile:
+
+    sys.ignore "CVS", /~$/
+
+In the Rant::FileList documentation there are five ways to create a
+filelist documented. In Rantfiles:
+
+    instead of                          |   use
+    -----------------------------------------------------------------
+    Rant::FileList.new                  |   sys.filelist
+    Rant::FileList[*patterns]           |   sys[*patterns]
+    Rant::FileList.glob(*patterns)      |   sys.glob(*patterns)
+    Rant::FileList.glob_all(*patterns)  |   sys.glob_all(*patterns)
+    Rant::FileList(list)                |   sys.filelist(list)
+
+The <tt>sys</tt> variants of filelist creation all honour the project
+wide ignore patterns set by <tt>sys.ignore</tt>.
+
+Let's look at an example. First an Rantfile using the "normal"
+filelist constructors:
+
+    all_files = FileList["**/*"].ignore("CVS", /~$/)
+    lib_files = FileList["lib/**/*.rb"].ignore("CVS")
+    pkg_files = FileList["bin/*", "lib/**/*.rb", "test/**/*"].ignore("CVS", /~$/)
+    backup_files = FileList["**/*~"]
+
+    # define tasks
+
+I admit that the example is a bit exaggerated, but in essence you
+always have to care that you don't accidently include a backup file or
+some file living under a "CVS" directory. Now look at the equivalent
+Rantfile using <tt>sys</tt> to create filelists.
+
+    sys.ignore "CVS", /~$/
+    all_files = sys["**/*"]
+    lib_files = sys["lib/**/*.rb"]
+    pkg_files = sys["bin/*", "lib/**/*.rb", "test/**/*"]
+    backup_files = FileList["**/*~"]
+
+    # define tasks
+
+Now, per default CVS directories and backup files won't appear in
+filelists. We use a "stateless" filelist for +backup_files+, since all
+backup files would be ignored otherwise.
+
+== Where to use filelists?
+
+Basically, you can use a filelist wherever you can use an array. The
+following is a list of use cases where filelists are handy.
+
+* As prerequisite list for a task. Example:
+
+    # get a list of all c files
+    c_files = sys["**/*.c"]
+    # get a list of all resulting object files
+    obj_files = c_files.ext("o")
+
+    # static library "foo" depends on all object files
+    file "libfoo.a" => obj_files do |t|
+        # build t.name from t.prerequisites (obj_files)
+    end
+
+* As argument to file system operations. Example:
+
+    task :clean do
+        # remove all backup files
+        sys.rm_f FileList["**/*~"]
+    end
+
+* If you want to apply an operation to a list of files, e.g.
+  substituting a variable in text files. Example:
+
+    # Do something with all files in the project
+    import "filelist/std"
+    sys["**/*"].files.each { |filename|
+        # do something with the file "filename"
+    }
+
+== See also
+
+Rant Overview::
+    README[link:files/README.html]
+Rant::FileList documentation::
+    doc/filelist.rdoc[link:files/doc/filelist_rdoc.html]
+Rantfile basics::
+    doc/rantfile.rdoc[link:files/doc/rantfile_rdoc.html]
+Advanced Rantfiles::
+    doc/advanced.rdoc[link:files/doc/advanced_rdoc.html]

data/lib/rant.rb

@@ -13,7 +13,7 @@ module Rant
         def inspect
             # what's the right encoding for object_id ?
             s = "#<#{self.class}:0x#{"%x" % object_id} "
-            s << "#{@actions.size} actions, #{@files.size} files"
+            s << "#{@actions.size} actions, #{@items.size} entries"
             if @ignore_rx
                 is = @ignore_rx.inspect.gsub(/\n|\t/, ' ')
                 s << ", ignore#{is.squeeze ' '}"

data/lib/rant/cs_compiler.rb

@@ -1,5 +1,5 @@
 
-require 'rant/rantenv'
+require 'rant/init'
 
 module Rant
     # An object extending this module acts as an
@@ -277,7 +277,7 @@ module Rant
 	    resources.each { |p|
 		cc_args << " -fresources=#{Env.shell_path(p)}"
 	    }
-	    cc_args << " " << sources.arglist if sources
+	    cc_args << " " << Rant::Sys.sp(sources) if sources
 	    cc_args
 	end
 
@@ -302,7 +302,7 @@ module Rant
 	    resources.each { |p|
 		cc_args << " /res:#{Env.shell_path(p)}"
 	    }
-	    cc_args << " " << sources.arglist if sources
+	    cc_args << " " << Rant::Sys.sp(sources) if sources
 	    cc_args
 	end
 
@@ -328,7 +328,7 @@ module Rant
 	    resources.each { |p|
 		cc_args << " -resource:#{Env.shell_path(p)}"
 	    }
-	    cc_args << " " << sources.arglist if sources
+	    cc_args << " " << Rant::Sys.sp(sources) if sources
 	    cc_args
 	end
 

data/lib/rant/filelist.rb

@@ -0,0 +1,8 @@
+
+# filelist.rb - Define Rant::FileList class.
+#
+# Copyright (C) 2005 Stefan Lang <langstefan@gmx.at>
+
+require 'rant/init'
+require 'rant/import/filelist/core'
+require 'rant/import/filelist/std'

data/lib/rant/import/archive.rb

@@ -154,16 +154,16 @@ module Rant::Generators::Archive
 	    fl = @files ? @files.dup : []
 	    if @manifest
                 fl = read_manifest unless @files
-                fl = Rant::RacFileList.filelist(@rac, fl)
-                fl << @manifest
+                fl = Rant::FileList(fl)
+                fl.keep(@manifest)
 	    elsif @files_only
-                fl = Rant::RacFileList.filelist(@rac, fl)
+                fl = Rant::FileList(fl)
 		fl.no_dirs
             else
-                fl = Rant::RacFileList.filelist(@rac, fl)
+                fl = Rant::FileList(fl)
 	    end
             # remove leading `./' relicts
-            @res_files = fl.lazy_map! { |fn| fn.sub(/^\.\/(?=.)/,'') }
+            @res_files = fl.map! { |fn| fn.sub(/^\.\/(?=.)/,'') }
             if defined?(@dist_path) && @dist_path
                 # Remove entries from the dist_path directory, which
                 # would create some sort of weird recursion.
@@ -172,7 +172,7 @@ module Rant::Generators::Archive
                 # but since I tapped into this trap frequently now...
                 @res_files.exclude(/^#{Regexp.escape @dist_path}/)
             end
-            @res_files.lazy_uniq!.lazy_sort!
+            @res_files.uniq!.sort!
 	end
 
 	# Creates an (eventually) temporary manifest file and yields

data/lib/rant/import/filelist/core.rb

@@ -0,0 +1,429 @@
+
+# core.rb - Core functionality for the Rant::FileList class.
+#
+# Copyright (C) 2005 Stefan Lang <langstefan@gmx.at>
+
+module Rant
+    def FileList(arg)
+        if arg.respond_to?(:to_rant_filelist)
+            arg.to_rant_filelist
+        elsif arg.respond_to?(:to_ary)
+            FileList.new(arg.to_ary)
+            # or?
+            #FileList.new.concat(arg.to_ary)
+        else
+            raise TypeError,
+                "cannot convert #{arg.class} into Rant::FileList"
+        end
+    end
+    module_function :FileList
+    class FileList
+        include Enumerable
+
+        ESC_SEPARATOR = Regexp.escape(File::SEPARATOR)
+        ESC_ALT_SEPARATOR = File::ALT_SEPARATOR ?
+            Regexp.escape(File::ALT_SEPARATOR) : nil
+
+        class << self
+            def [](*patterns)
+                new.hide_dotfiles.include(*patterns)
+            end
+            def glob(*patterns)
+                fl = new.hide_dotfiles.ignore(".", "..").include(*patterns)
+                if block_given? then yield fl else fl end
+            end
+            def glob_all(*patterns)
+                fl = new.ignore(".", "..").include(*patterns)
+                if block_given? then yield fl else fl end
+            end
+        end
+
+        def initialize(store = [])
+            @pending = false
+            @def_glob_dotfiles = true
+            @items = store
+            @ignore_rx = nil
+            @keep = {}
+            @actions = []
+        end
+        alias _object_dup dup
+        private :_object_dup
+        def dup
+            c = _object_dup
+            c.items = @items.dup
+            c.actions = @actions.dup
+            c.ignore_rx = @ignore_rx.dup if @ignore_rx
+            c.instance_variable_set(:@keep, @keep.dup)
+            c
+        end
+        def copy
+            c = _object_dup
+            c.items = @items.map { |entry| entry.dup }
+            c.actions = @actions.dup
+            c.ignore_rx = @ignore_rx.dup if @ignore_rx
+            # alternative approach: copy & freeze "keep" entries on
+            # inclusion in the keep hash
+            h_keep = {}
+            @keep.each_key { |entry| h_keep[entry] = true }
+            c.instance_variable_set(:@keep, h_keep)
+            c
+        end
+        # Currently for Rant internal use only. Might go in future
+        # releases.
+        def glob_dotfiles?
+            @def_glob_dotfiles
+        end
+        # Currently for Rant internal use only. Might go in future
+        # releases.
+        def glob_dotfiles=(flag)
+            @def_glob_dotfiles = flag ? true : false
+        end
+        # Has the same effect as <tt>glob_dotfiles = false</tt>.
+        #
+        # Returns self.
+        #
+        # Currently for Rant internal use only. Might go in future
+        # releases.
+        def hide_dotfiles
+            @def_glob_dotfiles = false
+            self
+        end
+        # Has the same effect as <tt>glob_dotfiles = true</tt>.
+        #
+        # Returns self.
+        #
+        # Currently for Rant internal use only. Might go in future
+        # releases.
+        def glob_dotfiles
+            @def_glob_dotfiles = true
+            self
+        end
+
+        protected
+        attr_accessor :actions, :items
+        attr_accessor :pending
+        attr_accessor :ignore_rx
+
+        public
+        def each(&block)
+            resolve if @pending
+            @items.each(&block)
+            self
+        end
+        def to_ary
+            resolve if @pending
+            @items
+        end
+        alias to_a to_ary
+        alias entries to_ary    # entries: defined in Enumerable
+        def to_rant_filelist
+            self
+        end
+        def +(other)
+            if other.respond_to? :to_rant_filelist
+                c = other.to_rant_filelist.dup
+                c.actions.concat(@actions)
+                c.items.concat(@items)
+                c.pending = !c.actions.empty?
+                c
+            elsif other.respond_to? :to_ary
+                c = dup
+                c.actions <<
+                    [:apply_ary_method_1, :concat, other.to_ary.dup]
+                c.pending = true
+                c
+            else
+                raise TypeError,
+                    "cannot add #{other.class} to Rant::FileList"
+            end
+        end
+        # Use this method to append +file+ to this list. +file+ will
+        # stay in this list even if it matches an exclude or ignore
+        # pattern.
+        #
+        # Returns self.
+        def <<(file)
+            @actions << [:apply_ary_method_1, :push, file]
+            @keep[file] = true
+            @pending = true
+            self
+        end
+        # Add +entry+ to this filelist. Position of +entry+ in this
+        # list is undefined. More efficient than #<<. +entry+ will
+        # stay in this list even if it matches an exclude or ignore
+        # pattern.
+        #
+        # Returns self.
+        def keep(entry)
+            @keep[entry] = true
+            @items << entry
+            self
+        end
+        # Append the entries of +ary+ (an array like object) to
+        # this list.
+        def concat(ary)
+            if @pending
+                ary = ary.to_ary.dup
+                @actions << [:apply_ary_method_1, :concat, ary]
+            else
+                ix = ignore_rx and ary = ary.to_ary.reject { |f| f =~ ix }
+                @items.concat(ary)
+            end
+            self
+        end
+        # Number of entries in this filelist.
+        def size
+            resolve if @pending
+            @items.size
+        end
+        alias length size
+        def empty?
+            resolve if @pending
+            @items.empty?
+        end
+        def join(sep = ' ')
+            resolve if @pending
+            @items.join(sep)
+        end
+        def pop
+            resolve if @pending
+            @items.pop
+        end
+        def push(entry)
+            resolve if @pending
+            @items.push(entry) if entry !~ ignore_rx
+            self
+        end
+        def shift
+            resolve if @pending
+            @items.shift
+        end
+        def unshift(entry)
+            resolve if @pending
+            @items.unshift(entry) if entry !~ ignore_rx
+            self
+        end
+if Object.method_defined?(:fcall) || Object.method_defined?(:funcall) # in Ruby 1.9 like __send__
+        @@__send_private__ = Object.method_defined?(:fcall) ? :fcall : :funcall
+        def resolve
+            @pending = false
+            @actions.each{ |action| self.__send__(@@__send_private__, *action) }.clear
+            ix = ignore_rx
+            if ix
+                @items.reject! { |f| f =~ ix && !@keep[f] }
+            end
+            self
+        end
+else
+        # Force evaluation of all patterns.
+        def resolve
+            @pending = false
+            @actions.each{ |action| self.__send__(*action) }.clear
+            ix = ignore_rx
+            if ix
+                @items.reject! { |f| f =~ ix && !@keep[f] }
+            end
+            self
+        end
+end
+        # Include entries matching one of +patterns+ in this filelist.
+        def include(*pats)
+            @def_glob_dotfiles ? glob_all(*pats) : glob_unix(*pats)
+        end
+        alias glob include
+        # Unix style glob: hide files starting with a dot
+        def glob_unix(*patterns)
+            patterns.flatten.each { |pat|
+                @actions << [:apply_glob_unix, pat]
+            }
+            @pending = true
+            self
+        end
+        def glob_all(*patterns)
+            patterns.flatten.each { |pat|
+                @actions << [:apply_glob_all, pat]
+            }
+            @pending = true
+            self
+        end
+        if RUBY_VERSION < "1.8.2"
+            # Dir.glob of Ruby releases before 1.8.2 returned dotfiles
+            # even if File::FNM_DOTMATCH was not set.
+            FN_DOTFILE_RX_ = ESC_ALT_SEPARATOR ?
+                /(^|(#{ESC_SEPARATOR}|#{ESC_ALT_SEPARATOR})+)\..*
+                    ((#{ESC_SEPARATOR}|#{ESC_ALT_SEPARATOR})+|$)/x :
+                /(^|#{ESC_SEPARATOR}+)\..* (#{ESC_SEPARATOR}+|$)/x
+            def apply_glob_unix(pattern)
+                inc_files = Dir.glob(pattern)
+                # it's not 100% correct, but it works for most use
+                # cases
+                unless pattern =~ /(^|\/)\./
+                    inc_files.reject! { |fn| fn =~ FN_DOTFILE_RX_ }
+                end
+                @items.concat(inc_files)
+            end
+        else
+            def apply_glob_unix(pattern)
+                @items.concat(Dir.glob(pattern))
+            end
+        end
+        private :apply_glob_unix
+        def apply_glob_all(pattern)
+            @items.concat(Dir.glob(pattern, File::FNM_DOTMATCH))
+        end
+        private :apply_glob_all
+        # Exclude all entries matching one of +patterns+ from this
+        # filelist.
+        #
+        # Note: Only applies to entries previousely included.
+        def exclude(*patterns)
+            patterns.each { |pat|
+                if Regexp === pat
+                    @actions << [:apply_exclude_rx, pat]
+                else
+                    @actions << [:apply_exclude, pat]
+                end
+            }
+            @pending = true
+            self
+        end
+        def ignore(*patterns)
+            patterns.each { |pat|
+                add_ignore_rx(Regexp === pat ? pat : mk_all_rx(pat))
+            }
+            @pending = true
+            self
+        end
+        def add_ignore_rx(rx)
+            @ignore_rx =
+            if @ignore_rx
+                Regexp.union(@ignore_rx, rx)
+            else
+                rx
+            end
+        end
+        private :add_ignore_rx
+        def apply_exclude(pattern)
+            @items.reject! { |elem|
+                File.fnmatch?(pattern, elem, File::FNM_DOTMATCH) && !@keep[elem]
+            }
+        end
+        private :apply_exclude
+        def apply_exclude_rx(rx)
+            @items.reject! { |elem|
+                elem =~ rx && !@keep[elem]
+            }
+        end
+        private :apply_exclude_rx
+        def exclude_name(*names)
+            names.each { |name|
+                @actions << [:apply_exclude_rx, mk_all_rx(name)]
+            }
+            @pending = true
+            self
+        end
+        alias shun exclude_name
+        if File::ALT_SEPARATOR
+            # TODO: check for FS case sensitivity?
+            def mk_all_rx(file)
+                /(^|(#{ESC_SEPARATOR}|#{ESC_ALT_SEPARATOR})+)#{Regexp.escape(file)}
+                    ((#{ESC_SEPARATOR}|#{ESC_ALT_SEPARATOR})+|$)/x
+            end
+        else
+            def mk_all_rx(file)
+                /(^|#{ESC_SEPARATOR}+)#{Regexp.escape(file)}
+                    (#{ESC_SEPARATOR}+|$)/x
+            end
+        end
+        private :mk_all_rx
+        def exclude_path(*patterns)
+            patterns.each { |pat|
+                @actions << [:apply_exclude_path, pat]
+            }
+            @pending = true
+            self
+        end
+        def apply_exclude_path(pattern)
+            flags = File::FNM_DOTMATCH|File::FNM_PATHNAME
+            @items.reject! { |elem|
+                File.fnmatch?(pattern, elem, flags) && !@keep[elem]
+            }
+        end
+        private :apply_exclude
+        def select(&block)
+            d = dup
+            d.actions << [:apply_select, block]
+            d.pending = true
+            d
+        end
+        alias find_all select
+        def apply_select blk
+            @items = @items.select(&blk)
+        end
+        private :apply_select
+        def map(&block)
+            d = dup
+            d.actions << [:apply_ary_method, :map!, block]
+            d.pending = true
+            d
+        end
+        alias collect map
+        def sub_ext(ext, new_ext=nil)
+            map { |f| f._rant_sub_ext ext, new_ext }
+        end
+        def ext(ext_str)
+            sub_ext(ext_str)
+        end
+        # Get a string with all entries. This is very usefull
+        # if you invoke a shell:
+        #       files # => ["foo/bar", "with space"]
+        #       sh "rdoc #{files.arglist}"
+        # will result on windows:
+        #       rdoc foo\bar "with space"
+        # on other systems:
+        #       rdoc foo/bar with\ space
+        def arglist
+            Rant::Sys.sp to_ary
+        end
+        alias to_s arglist
+        alias object_inspect inspect
+        # Same as #uniq! but evaluation is delayed until the next read
+        # access (e.g. by calling #each). Always returns self.
+        def uniq!
+            @actions << [:apply_ary_method, :uniq!]
+            @pending = true
+            self
+        end
+        # Same as #sort! but evaluation is delayed until the next read
+        # access (e.g. by calling #each). Always returns self.
+        def sort!
+            @actions << [:apply_ary_method, :sort!]
+            @pending = true
+            self
+        end
+        # Same as #map! but evaluation is delayed until the next read
+        # access (e.g. by calling #each). Always returns self.
+        def map!(&block)
+            @actions << [:apply_ary_method, :map!, block]
+            @pending = true
+            self
+        end
+        def reject!(&block)
+            @actions << [:apply_ary_method, :reject!, block]
+            @pending = true
+            self
+        end
+        private
+        def apply_ary_method(meth, block=nil)
+            @items.send meth, &block
+        end
+        def apply_ary_method_1(meth, arg1, block=nil)
+            @items.send meth, arg1, &block
+        end
+=begin
+        def apply_lazy_operation(meth, args, block)
+            @items.send(meth, *args, &block)
+        end
+=end
+    end # class FileList
+end # module Rant