rant 0.4.2 → 0.4.4

data/lib/rant/rantsys.rb

@@ -19,7 +19,8 @@ module Rant
 	# Initialized to 0.
 	attr_accessor :glob_flags
 	
-	attr_reader :ignore_rx
+	attr_accessor :ignore_rx
+        protected :ignore_rx=
 
 	class << self
 	    def [](*patterns)
@@ -33,6 +34,7 @@ module Rant
 	    @actions = patterns.map { |pat| [:apply_include, pat] }
 	    @ignore_rx = nil
 	    @pending = true
+            @keep = {}
 	    yield self if block_given?
 	end
 
@@ -41,6 +43,7 @@ module Rant
 	    c.files = @files.dup
 	    c.actions = @actions.dup
 	    c.ignore_rx = @ignore_rx.dup if @ignore_rx
+            c.instance_variable_set(:@keep, @keep.dup)
 	    c
 	end
 
@@ -67,35 +70,32 @@ module Rant
 	end
 
 	def +(other)
-	    case other
-	    when Array
-		c = dup
-		c.files.concat(other)
-		c
-	    when FileList
+            if FileList === other
 		c = other.dup
 		c.actions.concat(@actions)
 		c.files.concat(@files)
 		c.pending = !c.actions.empty?
 		c
-	    else
+            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 "argument has to be an Array or FileList"
-	    end
+            end
 	end
 
-        # Add file to filelist unless it matches an exclude pattern.
-        # Take care: Don't rely on any order when inserting a file
-        # with this method!
-	def add(file)
-	    @files << file unless file =~ ignore_rx
-	    self
-	end
-
-        # Like #add but doesn't honor exclude patterns.
+        # 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)
-            #STDERR.puts caller unless String === file
             @actions << [:apply_ary_method_1, :push, file]
+            @keep[file] = true
+            @pending = true
             self
         end
 
@@ -132,7 +132,7 @@ module Rant
 	    @actions.clear
 	    ix = ignore_rx
 	    if ix
-		@files.reject! { |f| f =~ ix }
+		@files.reject! { |f| f =~ ix && !@keep[f] }
 	    end
 	end
 
@@ -182,14 +182,14 @@ module Rant
 
 	def apply_exclude(pattern)
 	    @files.reject! { |elem|
-		File.fnmatch? pattern, elem, @glob_flags
+		File.fnmatch?(pattern, elem, @glob_flags) && !@keep[elem]
 	    }
 	end
 	private :apply_exclude
 
 	def apply_exclude_rx(rx)
 	    @files.reject! { |elem|
-		elem =~ rx
+		elem =~ rx && !@keep[elem]
 	    }
 	end
 	private :apply_exclude_rx
@@ -262,12 +262,13 @@ module Rant
 	    entry = nil
 	    unless name
 		@files.reject! { |entry|
-		    test(?d, entry)
+		    test(?d, entry) && !@keep[entry]
 		}
 		return
 	    end
 	    elems = nil
 	    @files.reject! { |entry|
+                next if @keep[entry]
 		elems = Sys.split_path(entry)
 		i = elems.index(name)
 		if i
@@ -283,7 +284,9 @@ module Rant
 	# Remove all files which have the given name.
 	def no_file(name)
             @actions << [:apply_ary_method, :reject!,
-                lambda { |entry| entry == name and test(?f, entry) }]
+                lambda { |entry|
+                    entry == name && !@keep[entry] && test(?f, entry)
+                }]
 	    @pending = true
 	    self
 	end
@@ -302,7 +305,7 @@ module Rant
 	    @files.reject! { |entry|
 		elems = Sys.split_path(entry)
 		elems.any? { |elem|
-		    elem =~ /#{suffix}$/
+		    elem =~ /#{suffix}$/ && !@keep[entry]
 		}
 	    }
 	end
@@ -321,7 +324,7 @@ module Rant
 	    @files.reject! { |entry|
 		elems = Sys.split_path(entry)
 		elems.any? { |elem|
-		    elem =~ /^#{prefix}/
+		    elem =~ /^#{prefix}/ && !@keep[entry]
 		}
 	    }
 	end
@@ -356,6 +359,8 @@ module Rant
             self
         end
 
+        # Same as #map! but evaluation is delayed until the next read
+        # access (e.g. by calling #each). Always returns self.
         def lazy_map!(&block)
             @actions << [:apply_ary_method, :map!, block]
             @pending = true
@@ -510,6 +515,13 @@ module Rant
 	def fu_output_message(msg)	#:nodoc:
 	    ::Rant.rac.cmd_msg msg if ::Rant.rac
 	end
+        private :fu_output_message
+
+        def fu_each_src_dest(src, *rest)
+            src = src.to_ary if src.respond_to? :to_ary
+            super(src, *rest)
+        end
+        private :fu_each_src_dest
 
 	# Run an external command. When given one argument, this is
 	# subject to shell interpretation. Otherwise the first
@@ -553,7 +565,7 @@ module Rant
 	    else
 		begin
 		    ln(*args)
-		rescue Errno::EOPNOTSUPP
+		rescue Exception #Errno::EOPNOTSUPP
 		    Sys.symlink_supported = false
 		    cp(*args)
 		end

data/lib/rant/rantvar.rb

@@ -16,7 +16,7 @@
 # If you're looking for general info about Rant, read the
 # README[link:files/README.html].
 module Rant
-    VERSION	= '0.4.2'
+    VERSION	= '0.4.4'
 
     # Those are the filenames for rantfiles.
     # Case matters!
@@ -52,7 +52,7 @@ module Rant
     end
 
     module MetaUtils
-	# Creates two accessor methods:
+	# Creates three accessor methods:
 	#    obj.attr_name::	Return value of instance variable
 	#			@attr_name
 	#    obj.attr_name = val::	Set value instance variable
@@ -72,6 +72,24 @@ module Rant
 	    EOD
 	    nil
 	end
+        # Creates three accessor methods:
+        #   obj.attr_name?::    Return value, true or false
+        #   obj.attr_name::     Set attribute to true
+        #   obj.no_attr_name::  Set attribute to false
+        def rant_flag attr_name
+            attr_name = valid_attr_name attr_name
+            module_eval <<-EOD
+                def #{attr_name}?
+                    @#{attr_name}
+                end
+                def #{attr_name}
+                    @#{attr_name} = true
+                end
+                def no_#{attr_name}
+                    @#{attr_name} = false
+                end
+            EOD
+        end
 	# Creates accessor methods like #rant_attr for the attribute
 	# attr_name. Additionally, values are converted with to_str
 	# before assignment to instance variables happens.
@@ -314,6 +332,18 @@ module Rant
 		!self[vid].nil?
 	    end
 
+            def _set(vid, val) #:nodoc:
+                @store[vid] = val
+            end
+
+            def _get(vid) #:nodoc:
+                @store[vid]
+            end
+
+            def _init(vid, val) #:nodoc:
+                @store[vid] ||= val
+            end
+
 	end	# class Space
 
 	module Constraint

data/misc/TODO

@@ -1,6 +1,72 @@
 
 = TODO
 
+== Improve SourceNode types
+
+Currently a SourceNode can only have other SourceNodes or files as
+prerequisites. But if e.g., a header file should be autogenerated,
+this isn't sufficient anymore.
+
+---
+Update
+
+Done (0.4.3) for SignedSourceNodes.
+
+== Deprecate plugin API
+
+... and provide alternatives for the Configure and CSharp plugins.
+
+== FileList
+
+FileList objects need a method which adds a file which won't be
+removed by any pattern (also not affected by var[:ignore]).
+
+---
+Done (0.4.3).
+
+Use FileList#<< to append a single entry which won't be removed by
+exclude/ignore patterns.
+
+== Semantics of directories as prerequisites of file creating nodes.
+
+Currently there are two so called "file creating" nodes: FileTask and
+SignedFile. The following treatments of a directory as prerequisite
+are possible:
+
+1. Current behaviour:
+   FileTask::   If a directory node exists, invoke it and compare if
+                the modification time of the directory is newer than
+                the target file.
+   SignedFile:: If a directory node exists, invoke it. If the
+                invocation return true, rebuild target file. If no
+                directory node exists, create a signature of the
+                directory by reading its entries and check this
+                signature against the signature of the last time the
+                target file was built.
+
+2. Just check if a directory node exists and invoke it. Trigger target
+   rebuild if +invoke+ returns true. If no node exists do nothing
+   special, the directory doesn't trigger a target file rebuild.
+
+I'm currently in favour of #2.
+
+---
+*Update*
+
+Current behaviour:
+FileTask::      If a directory node exists, invoke it and compare if
+                the modification time of the directory is newer than
+                the target file. If no node exists, just compare the
+                modification time.
+SignedFile::    If a directory node exists, invoke it and trigger a
+                rebuild if +invoke+ returns true. Anyway create a
+                signature of the path, which results in a rebuild if
+                the directory path changes once. This could be
+                considered an inconsistency since path/name changes of
+                other prerequisites don't trigger a rebuild.
+
+== Don't use testrb as testrunner for RubyTest.
+
 == Solve archiving dependency problem
 Because of timed depdencies, the archiving tasks don't recognize if
 the only change is that a file was removed. The only exception is a

data/test/import/c/dependencies/test_on_the_fly.rb

@@ -41,4 +41,56 @@ class TestImportCDependenciesOnTheFly < Test::Unit::TestCase
 	assert_rant("-frf.t")
 	assert(File.mtime("bar.t") > old_mtime)
     end
+    def write(fn, content)
+        open fn, "w" do |f|
+            f.write content
+        end
+    end
+    def test_md5
+        write "include/a.tt", <<-EOF
+            void abc(void);
+        EOF
+        write "a.tt", <<-EOF
+            #include "a.tt"
+        EOF
+        write "rf.t", <<-EOF
+            import "md5", "c/dependencies", "autoclean"
+            gen C::Dependencies,
+                :search => ["include"],
+                :sources => ["a.tt", "include/a.tt"]
+            gen Action do source "c_dependencies" end
+            gen AutoClean
+            file "a.out" => "a.tt" do |t|
+                sys.cp t.source, t.name
+            end
+        EOF
+        out, err = assert_rant("-frf.t", "a.out")
+        assert(err.empty?)
+        assert(!out.empty?)
+        assert(test(?f, "c_dependencies"))
+        assert(test(?f, "a.out"))
+        assert_equal(File.read("a.tt"), File.read("a.out"))
+        out, err = assert_rant("-frf.t", "a.out")
+        assert(err.empty?)
+        assert(out.empty?)
+        write "include/a.tt", <<-EOF
+            int abc(void);
+        EOF
+        out, err = assert_rant("-frf.t", "a.out")
+        assert(err.empty?)
+        assert(!out.empty?)
+        assert(test(?f, "c_dependencies"))
+        assert(test(?f, "a.out"))
+        assert_equal(File.read("a.tt"), File.read("a.out"))
+        out, err = assert_rant("-frf.t", "a.out")
+        assert(err.empty?)
+        assert(out.empty?)
+        assert_rant("-frf.t", "autoclean")
+        assert(!test(?e, ".rant.meta"))
+        assert(!test(?e, "a.out"))
+        assert(test(?f, "include/a.tt"))
+        assert(test(?f, "a.tt"))
+    ensure
+        FileUtils.rm_f %w(include/a.tt a.tt rf.t a.out .rant.meta)
+    end
 end

data/test/import/metadata/Rantfile

@@ -0,0 +1,16 @@
+
+import "metadata"
+
+task :dummy
+
+p var[:__metadata__].fetch("cmd", "a")
+var[:__metadata__].set("cmd", "touch a", "a")
+
+if var[:subdir]
+    subdirs "sub"
+    rac.goto "sub"
+        p var[:__metadata__].fetch("cmd", "b", "sub")
+    rac.goto "#"
+else
+    p var[:__metadata__].fetch("cmd", "a")
+end

data/test/import/metadata/sub/Rantfile

@@ -0,0 +1,17 @@
+
+gen Task, "b" do |t|
+    t.needed {
+        #puts Dir.pwd
+        #puts rac.current_subdir
+        rv = var[:__metadata__].fetch("cmd", "b") != "create b"
+        #p var[:__metadata__].fetch("cmd", "b")
+        #p var[:__metadata__].instance_variable_get(:@read_dirs)
+        #p var[:__metadata__].instance_variable_get(:@store)
+        rv
+    }
+    t.act {
+        sys.touch t.name
+        var[:__metadata__].set("cmd", "create b", "b")
+        #p var[:__metadata__].instance_variable_get(:@store)
+    }
+end

data/test/import/metadata/test_metadata.rb

@@ -0,0 +1,126 @@
+
+require 'test/unit'
+require 'tutil'
+
+$testImportMetaDataDir ||= File.expand_path(File.dirname(__FILE__))
+
+class TestMetaData < Test::Unit::TestCase
+    def setup
+	# Ensure we run in test directory.
+	Dir.chdir($testImportMetaDataDir)
+    end
+    def teardown
+	Dir.chdir($testImportMetaDataDir)
+	FileUtils.rm_rf(Dir["*.t"] + %w(.rant.meta sub/.rant.meta sub/b))
+    end
+    def test_fetch_set_fetch
+        out, err = assert_rant
+        assert(err.empty?)
+        assert_equal("nil\n\"touch a\"\n", out)
+        out, err = assert_rant
+        assert(err.empty?)
+        assert_equal("\"touch a\"\n\"touch a\"\n", out)
+    end
+    def test_subdir
+        out, err = assert_rant("subdir=true", "sub/b")
+        assert(err.empty?)
+        assert_equal("nil\nnil\ntouch b\n", out)
+        assert(test(?f, ".rant.meta"))
+        assert(test(?f, "sub/.rant.meta"))
+        out, err = assert_rant("subdir=true", "sub/b")
+        assert(err.empty?)
+        assert_equal("\"touch a\"\n\"create b\"\n", out)
+    end
+    def test_rant_import
+        run_import("-q", "--auto", "make.t")
+        assert_exit
+        FileUtils.rm ".rant.meta"
+        out = run_ruby("make.t", "subdir=true", "sub/b")
+        assert_exit
+        assert_equal("nil\nnil\ntouch b\n", out)
+        assert(test(?f, ".rant.meta"))
+        assert(test(?f, "sub/.rant.meta"))
+        out = run_ruby("make.t", "subdir=true", "sub/b")
+        assert_exit
+        assert_equal("\"touch a\"\n\"create b\"\n", out)
+    end
+    def test_more_commands_and_lines
+        FileUtils.mkdir "more.t"
+        Dir.chdir "more.t"
+        open "Rantfile", "w" do |f|
+            f << <<-EOF
+            import "metadata"
+            task :dummy
+            puts var[:__metadata__].fetch("x", "a")
+            puts var[:__metadata__].fetch("y", "a")
+            puts var[:__metadata__].fetch("x", "b")
+            #STDERR.puts(var[:__metadata__].instance_variable_get(:@store).inspect)
+            var[:__metadata__].set("x", "1\n2\n\n", "a")
+            var[:__metadata__].set("y", "3\n4", "a")
+            var[:__metadata__].set("x", "5", "b")
+            #STDERR.puts(var[:__metadata__].instance_variable_get(:@store).inspect)
+            EOF
+        end
+        out, err = assert_rant
+        assert(err.empty?)
+        assert_equal("nil\nnil\nnil\n", out)
+        assert(test(?f, ".rant.meta"))
+        out, err = assert_rant
+        assert(err.empty?)
+        assert_equal("1\n2\n3\n4\n5\n", out)
+        out, err = assert_rant
+        assert(err.empty?)
+        assert_equal("1\n2\n3\n4\n5\n", out)
+    end
+    def test_write_current_version
+            top_data = <<EOF
+Rant
+a
+1
+cmd
+1
+touch a
+EOF
+            sub_data = <<EOF
+Rant
+b
+1
+cmd
+1
+create b
+EOF
+        assert_rant("subdir=true", "sub/b")
+        assert_equal(top_data, File.read(".rant.meta"))
+        assert_equal(sub_data, File.read("sub/.rant.meta"))
+    end
+    def test_read_meta_data_format_version_0_4_4
+        assert(!test(?e, ".rant.meta"))
+        assert(!test(?e, "sub/.rant.meta"))
+        open ".rant.meta", "w" do |f|
+            f << <<EOF
+Rant
+a
+1
+cmd
+1
+touch a
+EOF
+        end
+        open "sub/.rant.meta", "w" do |f|
+            f << <<EOF
+Rant
+b
+1
+cmd
+1
+create b
+EOF
+        end
+        out, err = assert_rant
+        assert(err.empty?)
+        assert_equal("\"touch a\"\n\"touch a\"\n", out)
+        out, err = assert_rant("subdir=true", "sub/b")
+        assert(err.empty?)
+        assert_equal("\"touch a\"\n\"create b\"\n", out)
+    end
+end

data/test/import/nodes/signed/Rantfile

@@ -0,0 +1,89 @@
+
+import "md5", "autoclean"
+
+var :content => "1\n"
+
+task :a => "f1.t"
+
+file "f1.t" do |t|
+    write_content(t.name)
+end
+
+gen Directory, "d1.t"
+
+gen Directory, "base.t", "s/s" => ["a.t", "f1.t"] do |t|
+    fn = t.name + "/t"
+    puts "copying to #{fn}"
+    open fn, "w" do |f|
+        f.write(File.read(t.source))
+        f.write(File.read("f1.t"))
+    end; sys.cd "sub1"
+end
+
+if var["subfile"]
+    import "subfile"
+    gen SubFile, "d2.t/f" => "f1.t" do |t|
+        sys.cp t.source, t.name
+    end
+end
+
+file "f2.t" => ["base.t/s/s"] do |t|
+    sys.cp "#{t.source}/t", t.name
+end
+
+gen SourceNode, "c1.t"
+
+gen SourceNode, "c2.t" => ["c1.t", "c3.t"]
+
+file "f3.t" => "c1.t" do |t|
+    var[:content] = File.read(t.source)
+    write_content(t.name)
+end
+
+file "f4.t" => ["f3.t", "c2.t"] do |t|
+    var[:content] = t.deps.inject("") { |c, fn| c + File.read(fn) }
+    write_content(t.name)
+end
+
+gen SourceNode, "c4.t" => "c2.t"
+
+file "f5.t" => "c2.t" do |t|
+    sys.cp t.source, t.name
+end
+
+gen SourceNode, "c5.t" => ["sub1/c1.t", "c6.t"]
+
+file "f6.t" => "c5.t" do |t|
+    write_content(t.name)
+end
+
+gen Rule, ".r.t" => ".t" do |t|
+    sys.cp t.source, t.name
+end
+
+gen Rule, ".r.t" => ".tt" do |t|
+    sys.cp t.source, t.name
+end
+
+gen SourceNode, "c7.t" => ["f1.t", "c8.t"]
+
+file "f7.t" => "c7.t" do |t|
+    sys.cp t.source, t.name
+    sys.cd "sub1"
+end
+
+desc "copy f1.t from sub1 to f8.t"
+file "f8.t" => "sub1/f1.t" do |t|
+    sys.cp t.source, t.name
+end
+
+subdirs "sub1"
+
+def write_content(fn)
+    puts "writing #{fn}"
+    open fn, "w" do |f|
+        f.write var[:content]
+    end
+end
+
+gen AutoClean

data/test/import/nodes/signed/sub1/Rantfile

@@ -0,0 +1,6 @@
+
+gen SourceNode, "c1.t" => "c2.t"
+
+file "f1.t" do |t|
+    write_content(t.name)
+end