rant 0.4.6 → 0.4.8

data/lib/rant/rantsys.rb

@@ -138,15 +138,36 @@ module Rant
 	end
 	##############################################################
 
-if Object.method_defined? :fcall # in Ruby 1.9 like __send__
+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.fcall(*action) }.clear
+	    @actions.each{ |action| self.__send__(@@__send_private__, *action) }.clear
 	    ix = ignore_rx
 	    if ix
 		@files.reject! { |f| f =~ ix && !@keep[f] }
 	    end
 	end
+elsif RUBY_VERSION < "1.8.2"
+	def resolve
+	    @pending = false
+	    @actions.each{ |action| self.__send__(*action) }.clear
+	    ix = ignore_rx
+            @files.reject! { |f|
+                unless @keep[f]
+                    next(true) if ix && f =~ ix
+                    if @glob_flags & File::FNM_DOTMATCH != File::FNM_DOTMATCH
+                        if ESC_ALT_SEPARATOR
+                            f =~ /(^|(#{ESC_SEPARATOR}|#{ESC_ALT_SEPARATOR})+)\..*
+                                ((#{ESC_SEPARATOR}|#{ESC_ALT_SEPARATOR})+|$)/x
+                        else
+                            f =~ /(^|#{ESC_SEPARATOR}+)\..*
+                                (#{ESC_SEPARATOR}+|$)/x
+                        end
+                    end
+                end
+            }
+	end
 else
 	def resolve
 	    @pending = false
@@ -359,9 +380,9 @@ end
 	# will result on windows:
 	#	rdoc foo\bar "with space"
 	# on other systems:
-	#	rdoc foo/bar 'with space'
+	#	rdoc foo/bar with\ space
 	def arglist
-	    to_ary.arglist
+            Rant::Sys.sp to_ary
 	end
         alias to_s arglist
 
@@ -422,10 +443,15 @@ end
 	    @basedir = Dir.pwd
 	    super(*patterns)
 	    @ignore_hash = nil
+            @add_ignore_args = []
 	    update_ignore_rx
 	end
 
-	private :ignore
+        alias filelist_ignore ignore
+        def ignore(*patterns)
+            @add_ignore_args.concat patterns
+            self
+        end
 
 	def ignore_rx
 	    update_ignore_rx
@@ -450,10 +476,11 @@ end
 	private
 	def update_ignore_rx
 	    ri = @rac.var[:ignore]
+            ri = ri ? (ri + @add_ignore_args) : @add_ignore_args
 	    rh = ri.hash
 	    unless rh == @ignore_hash
 		@ignore_rx = nil
-		ignore(*ri) if ri
+		filelist_ignore(*ri)
 		@ignore_hash = rh
 	    end
 	end
@@ -571,18 +598,51 @@ end
                 # The empty string argument ensures that +system+
                 # doesn't start a subshell but invokes ruby directly.
                 # The empty string argument is ignored by ruby.
-                sh(Env::RUBY, '', &block)
+                sh(Env::RUBY_EXE, '', &block)
             else
-                sh(args.unshift(Env::RUBY), &block)
+                sh(args.unshift(Env::RUBY_EXE), &block)
             end
 	end
 
 	# Returns a string that can be used as a valid path argument
 	# on the shell respecting portability issues.
-	def sp path
-	    Env.shell_path path
+	def sp(arg)
+            if arg.respond_to? :to_ary
+                arg.to_ary.map{ |e| sp e }.join(' ')
+            else
+                _escaped_path arg
+            end
 	end
 
+        # Escape special shell characters (currently only spaces).
+        # Flattens arrays and returns always a single string.
+        def escape(arg)
+            if arg.respond_to? :to_ary
+                arg.to_ary.map{ |e| escape e }.join(' ')
+            else
+                _escaped arg
+            end
+        end
+
+        if Env.on_windows?
+            def _escaped_path(path)
+		_escaped(path.to_s.tr("/", "\\"))
+            end
+            def _escaped(arg)
+		sarg = arg.to_s
+		return sarg unless sarg.include?(" ")
+		sarg << "\\" if sarg[-1].chr == "\\"
+                "\"#{sarg}\""
+            end
+        else
+            def _escaped_path(path)
+                path.to_s.gsub(/(?=\s)/, "\\")
+            end
+            alias _escaped _escaped_path
+        end
+        private :_escaped_path
+        private :_escaped
+
 	# If supported, make a hardlink, otherwise
 	# fall back to copying.
 	def safe_ln(*args)
@@ -612,7 +672,7 @@ end
 
 	extend self
 
-        if RUBY_VERSION >= "1.9.0"
+        if RUBY_VERSION >= "1.8.4"  # needed by 1.9.0, too
             class << self
                 public(*::FileUtils::METHODS)
             end
@@ -634,12 +694,20 @@ end
 		raise ArgumentError, "controller required"
 	end
 
-	def glob(*args, &block)
-	    fl = RacFileList.new(@rac, *args)
+	def glob(*patterns, &block)
+	    fl = RacFileList.new(@rac, *patterns)
 	    fl.instance_eval(&block) if block
 	    fl
 	end
 
+        def glob_all(*patterns, &block)
+	    fl = RacFileList.new(@rac, *patterns)
+            fl.ignore(".", "..")
+            fl.glob_flags |= File::FNM_DOTMATCH
+	    fl.instance_eval(&block) if block
+	    fl
+        end
+
 	def [](*patterns)
 	    RacFileList.new(@rac, *patterns)
 	end

data/lib/rant/rantvar.rb

@@ -16,14 +16,13 @@
 # If you're looking for general info about Rant, read the
 # README[link:files/README.html].
 module Rant
-    VERSION = '0.4.6'
+    VERSION = '0.4.8'
 
     # Those are the filenames for rantfiles.
     # Case matters!
     ROOT_RANTFILE = "root.rant"
     SUB_RANTFILE = "sub.rant"
     RANTFILES = [ "Rantfile", "rantfile", ROOT_RANTFILE ]
-    DEPRECATED_RANTFILES = [ "Rantfile.rb", "rantfile.rb" ]
     
     # Names of plugins and imports for which code was loaded.
     # Files that where loaded with the `import' commant are directly
@@ -49,80 +48,6 @@ module Rant
 	@__rant_no_value__
     end
 
-    module MetaUtils
-	# Creates three accessor methods:
-	#    obj.attr_name::	Return value of instance variable
-	#			@attr_name
-	#    obj.attr_name = val::	Set value instance variable
-	#				@attr_name to val
-	#    obj.attr_name val::	same as above
-	def rant_attr attr_name
-	    attr_name = valid_attr_name attr_name
-	    attr_writer attr_name
-	    module_eval <<-EOD
-		def #{attr_name} val=Rant.__rant_no_value__
-		    if val.equal? Rant.__rant_no_value__
-			@#{attr_name}
-		    else
-			@#{attr_name} = val
-		    end
-		end
-	    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.
-	def string_attr attr_name
-	    attr_name = valid_attr_name attr_name
-	    module_eval <<-EOD
-		def #{attr_name}=(val)
-		    if val.respond_to? :to_str
-			@#{attr_name} = val.to_str
-		    else
-			raise ArgumentError,
-			    "string (#to_str) value required", caller
-		    end
-		end
-		def #{attr_name} val=Rant.__rant_no_value__
-		    if val.equal? Rant.__rant_no_value__
-			@#{attr_name}
-		    else
-			self.__send__(:#{attr_name}=, val)
-		    end
-		end
-	    EOD
-	    nil
-	end
-	# attr_name is converted to a string with #to_s and has to
-	# match /^\w+$/. Returns attr_name.to_s.
-	def valid_attr_name attr_name
-	    attr_name = attr_name.to_s
-	    attr_name =~ /^\w+$/ or
-		raise ArgumentError,
-		    "argument has to match /^\w+$/", caller
-	    attr_name
-	end
-    end # module MetaUtils
-
     module RantVar
 
 	class Error < Rant::Error

data/lib/rant.rb

@@ -60,9 +60,9 @@ module Rant
 end
 
 def rant
-    @__rant__
+    Rant.rant
 end
 
-@__rant__ = Rant::RantApp.new
+Rant.instance_variable_set(:@__rant__, Rant::RantApp.new)
 
 include RantContext

data/misc/TODO

@@ -1,6 +1,25 @@
 
 = TODO
 
+== Don't use +invoke+ result of dependency to check if update is
+   necessary
+
+It doesn't make sense since:
+1. The node (prerequisite) could have already been invoked by another
+   node as prerequisite. For the first node, the prerequisite would
+   return true, all following false.
+2. The node (prerequisite) *can* *not* know if the invoking node is
+   up to date compared to itself.
+
+== Check +enhance+ for SourceNodes
+
+Rant fails (infinite recursion) for enhance on SourceNodes.
+Update: Infinite recursion occurs only when a <tt>require "rant"</tt>
+        was done. Else an appropriate message is printed. Can be
+        considered OK.
+
+== Implement Rant::FileList#==
+
 == Update documentation with regards to resolve hooks.
 
 The argument list for resolve hooks has changed in version 0.4.5.
@@ -18,6 +37,8 @@ could get a common source of annoyance/bugs.
 
 Favorite candidate is currently <tt>@</tt>.
 
+Done (0.4.5), using <tt>@</tt>.
+
 == Improve SourceNode types
 
 Currently a SourceNode can only have other SourceNodes or files as

data/test/deprecated/test_0_5_2.rb

@@ -30,4 +30,32 @@ class TestDeprecated_0_5_2 < Test::Unit::TestCase
             assert_match(/\bdeprecated\b/, err)
         end
     end
+    def test_ary_arglist
+        in_local_temp_dir do
+            write_to_file "Rantfile", <<-EOF
+                task :default do
+                    sys(sys.sp(Env::RUBY_EXE) + " -e \\"puts ARGV\\" " +
+                        ["a b", "c/d"].arglist + " > a.out")
+                end
+            EOF
+            out, err = assert_rant
+            content = Rant::Env.on_windows? ? "a b\nc\\d\n" : "a b\nc/d\n"
+            assert_file_content "a.out", content
+            assert_match(/\bWARNING\b/, err)
+            assert_match(/\barglist\b/, err)
+            assert_match(/\bsp\b/, err)
+            assert_match(/\bdeprecated\b/, err)
+        end
+    end
+    def test_ary_shell_pathes
+        out, err = capture_std do
+            sp = ["a b", "a/b"].shell_pathes
+            assert sp.respond_to?(:to_ary)
+            assert_equal 2, sp.size
+        end
+        assert_match(/\bWARNING\b/, err)
+        assert_match(/\bshell_pathes\b/, err)
+        assert_match(/\bsp\b/, err)
+        assert_match(/\bdeprecated\b/, err)
+    end
 end

data/test/deprecated/test_0_6_0.rb

@@ -0,0 +1,24 @@
+
+require 'test/unit'
+require 'tutil'
+require 'rant/import'
+
+$test_deprecated_dir ||= File.expand_path(File.dirname(__FILE__))
+
+class TestDeprecated_0_6_0 < Test::Unit::TestCase
+    include Rant::TestUtil
+    def setup
+        Dir.chdir $test_deprecated_dir
+    end
+    def test_rant_import_option_v
+        out, err = capture_std do
+            assert_equal(0, Rant::RantImport.new("-v").run)
+        end
+        if Rant::VERSION > "0.4.8"
+            assert_match(/-v\bdeprecated\b.*-V.*--version\b/, err)
+        else
+            assert err.empty?
+        end
+        assert_match(/rant-import\s#{Regexp.escape Rant::VERSION}/, out)
+    end
+end

data/test/dyn_dependencies.rf

@@ -0,0 +1,25 @@
+
+import "sys/more", "autoclean"
+
+@print = lambda { |t| puts t.name }
+@write = lambda { |t|
+    sys.write_to_file(t.name, (var[t.name[0,1]]||t.name))
+}
+
+task :A => :B, &@print
+task :B do |t|
+    enhance :A => [:C, :D]
+    @print[t]
+end
+task :C, &@print
+task :D, &@print
+
+file "a.t" => "b.t", &@write
+file "b.t" do |t|
+    enhance "a.t" => ["c.t", "d.t"]
+    @write[t]
+end
+file "c.t", &@write
+file "d.t", &@write
+
+gen AutoClean

data/test/import/command/Rantfile

@@ -0,0 +1,102 @@
+
+import "command", "autoclean"
+
+@ruby = Env::RUBY_EXE
+@sh_echo = "#{sys.sp Env::RUBY_EXE} -e \"puts ARGV.join(' ')\""
+@sh_puts = "#{sys.sp Env::RUBY_EXE} -e \"puts ARGV\""
+@sh_cat = "#{sys.sp Env::RUBY_EXE} -e \"print ARGF.read\""
+
+desc "Build a.t"
+gen Command, "a.t" => ["b.t", "c.t"] do |t|
+    "#@sh_echo #{sys.sp t.prerequisites} > #{t.name}"
+end
+gen Command, "f_a.t" do |t|
+    sys "#@sh_echo #{sys.escape "I will fail."} > #{t.name}"
+end
+
+var :btxt => "b"
+var :be, :Bool
+
+gen Command, "b.t", "$[sh_echo] $(btxt) > $(>)"
+
+if var[:be]
+    enhance "b.t" => "d.t" do |t|
+        import "sys/more"
+        sys.write_to_file(t.name,
+            File.read(t.name) + File.read(t.source))
+    end
+end
+
+gen Command, "c.t", sys["d???.t"], "$[sh_echo] $(<) > $(>)"
+
+gen Command, "with space/a.t",
+    ["b.t", "with space/b.t"],
+    "$[sh_puts] $(<) > $(>)"
+
+var :fargs => "/I$(p_ath1)"
+var :p_ath1 => "a bc"
+gen Command, "f.t", "$[sh_echo] $[fargs] > $[>]"
+
+var :eargs => "/I$(epath)"
+var :epath => "a b/c/"
+gen Command, "e.t", "$[sh_echo] $[eargs] > ${>}"
+
+var :gargs => "/I${gpath}"
+var :gpath => "a b/c/"
+gen Command, "g.t", "$[sh_echo] $[gargs] > $(>)"
+
+var :h1 => 1
+var :h2 => 2
+gen Command, "h.t", <<end
+$[sh_echo] ${h1} > $(>)1
+$[sh_echo] ${h2} > $(>)2
+$[sh_cat] $(>)1 $(>)2 > $(>)
+end
+
+var :rargs => "$(prerequisites) $(source) > $(name)"
+var :rcmd => "$[sh_echo] " + var[:rargs]
+gen Rule, :out => [:in1, :in2] do |name, sources|
+    gen Command, name, sources, var[:rcmd]
+end
+
+gen Directory, "a.in1"
+
+var :rc_dep => "puts 'a'"
+gen Command, "dep1.t", "$(ruby) -e \"$[rc_dep]\" > $(>)"
+
+gen Command, "t1.t", "dep1.t", "$[sh_echo] making t1 > $(>)"
+gen Command, "t2.t", "dep1.t", "$[sh_echo] making t2 > $(>)"
+
+gen Command, "sub1.t/a", "#@sh_echo ${>} > $(>)"
+gen Command, "sub2.t/a", "$[sh_echo] ${>} > $(>)"
+gen Directory, "sub2.t"
+
+task :sub3 do
+    puts "task sub3"
+end
+gen Command, "sub3/a", "$[sh_echo] ${>} > $(>)"
+
+gen Command, "x.t", '[#$[sh_puts] ${a}#] ${b} > $(>)'
+
+gen Command, "delay.t", "$[sh_echo] ${foo} > $(>)"
+
+gen Command, "p1.t", '$[sh_puts] ${p1} > $(>)'
+gen Command, "p2.t", '$[sh_puts] ${p2} > $(>)'
+gen Command, "p3.t", '$[sh_puts] ${p2} > $(>)'
+
+var :foo => "foo value"
+task :change_foo do
+    var[:foo] = "changed"
+end
+
+var[:p1] = lambda { |n| "#{n.full_name} $[foo]" }
+var[:p2] = lambda { var[:foo] << "." }
+
+if var[:inc_foo]
+    var[:p2].call
+end
+
+@h = {:a => "b"}
+gen Command, "hash.t", "$[sh_puts] ${h} > $(>)"
+
+gen AutoClean