rant 0.5.0 → 0.5.2

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

@@ -0,0 +1,57 @@
+
+# inspect.rb - Custom inspect method for Rant::FileList instances.
+#
+# Copyright (C) 2005 Stefan Lang <langstefan@gmx.at>
+
+module Rant
+    class FileList
+        # Note that the default Object#inspect implementation is
+        # available as +object_inspect+.
+        def inspect
+            # empirisch ermittelt ;)
+            s = "#<#{self.class}:0x%x " % (object_id << 1)
+
+            s << "glob:" << (glob_dotfiles? ? "all" : "unix") << " "
+            if ix = ignore_rx
+                is = ix.source.dup
+                is.gsub!(/ +/, ' ')
+                is.gsub!(/\n/, '\n')
+                is.gsub!(/\t/, '\t')
+                is[10..-1] = "..." if is.length > 12
+                s << "i:#{is} "
+            end
+
+            if @pending
+                s << "res:#{@actions.size} "
+            end
+
+            unless @keep.empty?
+                s << "keep:#{@keep.size} "
+            end
+
+            s << "entries:#{items.size}"
+            if @items.size > 0
+                s << "["
+                if @items.size == 1
+                    is = @items.first.dup
+                    is[15..-1] = "..." if is.length > 16
+                    is = '"' << is << '"'
+                else
+                    fs = @items.first.dup
+                    fs[11..-1] = "..." if fs.length > 12
+                    fs = '"' << fs << '"'
+                    ls = @items.last.dup
+                    ls[0..-11] = "..." if ls.length > 12
+                    ls = '"' << ls << '"'
+                    if @items.size == 2
+                        is = "#{fs}, #{ls}"
+                    else
+                        is = "#{fs}, ..., #{ls}"
+                    end
+                end
+                s << "#{is}]"
+            end
+            s << ">"
+        end
+    end # class FileList
+end # module Rant

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

@@ -0,0 +1,64 @@
+
+# std.rb - Additional set of Rant::FileList instance methods.
+#
+# Copyright (C) 2005 Stefan Lang <langstefan@gmx.at>
+
+# What should this file be used for:
+#
+# Place <code>import "filelist/std"</code> in an Rantfile to get all
+# functionality as defined after <code>require "rant/filelist"</code>
+# (for use as library). Read doc/filelist.rdoc.
+
+require 'rant/import/filelist/inspect'
+
+module Rant
+    class FileList
+        # Remove all entries which contain a directory with the
+        # given name.
+        # If no argument or +nil+ given, remove all directories.
+        #
+        # Example:
+        #       file_list.no_dir "CVS"
+        # would remove the following entries from file_list:
+        #       CVS/
+        #       src/CVS/lib.c
+        #       CVS/foo/bar/
+        def no_dir(name = nil)
+            @actions << [:apply_no_dir, name]
+            @pending = true
+            self
+        end
+        def apply_no_dir(name)
+            entry = nil
+            unless name
+                @items.reject! { |entry|
+                    test(?d, entry) && !@keep[entry]
+                }
+                return
+            end
+            elems = nil
+            @items.reject! { |entry|
+                next if @keep[entry]
+                elems = Sys.split_all(entry)
+                i = elems.index(name)
+                if i
+                    path = File.join(*elems[0..i])
+                    test(?d, path)
+                else
+                    false
+                end
+            }
+        end
+        private :apply_no_dir
+        # Get a new filelist containing only the existing files from
+        # this filelist.
+        def files
+            select { |entry| test ?f, entry }
+        end
+        # Get a new filelist containing only the existing directories
+        # from this filelist.
+        def dirs
+            select { |entry| test ?d, entry }
+        end
+    end # class FileList
+end # module Rant

data/lib/rant/import/nodes/default.rb

@@ -222,8 +222,12 @@ module Rant
 		    end
 		end
 	    }
-	    @pre.flatten!
-	    @pre.compact!
+            if @pre.kind_of? Rant::FileList
+                @pre.resolve
+            else
+                @pre.flatten!
+                @pre.compact!
+            end
 	    @pre_resolved = true
 	end
     end	# class Task

data/lib/rant/import/rubypackage.rb

@@ -244,6 +244,16 @@ class Rant::Generators::RubyPackage
 	    spec = Gem::Specification.new do |s|
 		map_to_gemspec(s)
 	    end
+
+            # fix for YAML bug in Ruby 1.8.3 and 1.8.4 previews
+            if RUBY_VERSION == "1.8.3" or
+                RUBY_VERSION == "1.8.4" && RUBY_RELEASE_DATE < "2005-12-24"
+                def spec.to_yaml(*args, &block)
+                    yaml = super
+                    yaml =~ /^---/ ? yaml : "--- #{yaml}"
+                end
+            end
+            
 	    fn = nil
 	    begin
 		fn = Gem::Builder.new(spec).build

data/lib/rant/init.rb

@@ -0,0 +1,200 @@
+
+# init.rb - Define constants and methods required by all Rant code.
+#
+# Copyright (C) 2005 Stefan Lang <langstefan@gmx.at>
+
+require 'rbconfig'
+
+unless Process::Status.method_defined?(:success?) # new in 1.8.2
+    class Process::Status
+        def success?; exitstatus == 0; end
+    end
+end
+unless Regexp.respond_to? :union # new in 1.8.1
+    def Regexp.union(*patterns)
+        # let's hope it comes close to ruby-1.8.1 and upwards...
+        return /(?!)/ if patterns.empty?
+        Regexp.new(patterns.join("|"))
+    end
+end
+if RUBY_VERSION < "1.8.2"
+    class Array
+        undef_method :flatten, :flatten!
+        def flatten
+            cp = self.dup
+            cp.flatten!
+            cp
+        end
+        def flatten!
+            res = []
+            flattened = false
+            self.each { |e|
+                if e.respond_to? :to_ary
+                    res.concat(e.to_ary)
+                    flattened = true
+                else
+                    res << e
+                end
+            }
+            if flattened
+                replace(res)
+                flatten!
+                self
+            end
+        end
+    end
+end
+
+class String
+    def _rant_sub_ext(ext, new_ext = nil)
+        if new_ext
+            self.sub(/#{Regexp.escape ext}$/, new_ext)
+        else
+            self.sub(/(\.[^.]*$)|$/, ".#{ext}")
+        end
+    end
+end
+
+module Rant
+    VERSION = '0.5.2'
+
+    @__rant_no_value__ = Object.new.freeze
+    def self.__rant_no_value__
+	@__rant_no_value__
+    end
+
+    module Env
+        OS = ::Config::CONFIG['target']
+        RUBY = ::Config::CONFIG['ruby_install_name']
+        RUBY_BINDIR = ::Config::CONFIG['bindir']
+        RUBY_EXE = File.join(RUBY_BINDIR, RUBY + ::Config::CONFIG["EXEEXT"])
+
+        @@zip_bin = false
+        @@tar_bin = false
+
+        if OS =~ /mswin/i
+            def on_windows?; true; end
+        else
+            def on_windows?; false; end
+        end
+
+        def have_zip?
+            if @@zip_bin == false
+                @@zip_bin = find_bin "zip"
+            end
+            !@@zip_bin.nil?
+        end
+        def have_tar?
+            if @@tar_bin == false
+                @@tar_bin = find_bin "tar"
+            end
+            !@@tar_bin.nil?
+        end
+        # Get an array with all pathes in the PATH
+        # environment variable.
+        def pathes
+            # Windows doesn't care about case in environment variables,
+            # but the ENV hash does!
+            path = ENV[on_windows? ? "Path" : "PATH"]
+            return [] unless path
+            path.split(on_windows? ? ";" : ":")
+        end
+        # Searches for bin_name on path and returns
+        # an absolute path if successfull or nil
+        # if an executable called bin_name couldn't be found.
+        def find_bin bin_name
+            if on_windows?
+                bin_name_exe = nil
+                if bin_name !~ /\.[^\.]{1,3}$/i
+                    bin_name_exe = bin_name + ".exe"
+                end
+                pathes.each { |dir|
+                    file = File.join(dir, bin_name)
+                    return file if test(?f, file)
+                    if bin_name_exe
+                        file = File.join(dir, bin_name_exe)
+                        return file if test(?f, file)
+                    end
+                }
+            else
+                pathes.each { |dir|
+                    file = File.join(dir, bin_name)
+                    return file if test(?x, file)
+                }
+            end
+            nil
+        end
+        # Add quotes to a path and replace File::Separators if necessary.
+        def shell_path path
+            # TODO: check for more characters when deciding wheter to use
+            # quotes.
+            if on_windows?
+                path = path.tr("/", "\\")
+                if path.include? ' '
+                    '"' + path + '"'
+                else
+                    path
+                end
+            else
+                if path.include? ' '
+                    "'" + path + "'"
+                else
+                    path
+                end
+            end
+        end
+        extend self
+    end # module Env
+
+    module Sys
+	# Returns a string that can be used as a valid path argument
+	# on the shell respecting portability issues.
+	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
+            def regular_filename(fn)
+                fn.to_str.tr("\\", "/").gsub(%r{/{2,}}, "/")
+            end
+        else
+            def _escaped_path(path)
+                path.to_s.gsub(/(?=\s)/, "\\")
+            end
+            alias _escaped _escaped_path
+            def regular_filename(fn)
+                fn.to_str.gsub(%r{/{2,}}, "/")
+            end
+        end
+        private :_escaped_path
+        private :_escaped
+	# Split a path in all elements.
+	def split_all(path)
+            names = regular_filename(path).split(%r{/})
+            names[0] = "/" if names[0] && names[0].empty?
+            names
+	end
+        extend self
+    end # module Sys
+end # module Rant

data/lib/rant/rantlib.rb

@@ -8,8 +8,8 @@
 # the GNU LGPL, Lesser General Public License version 2.1.
 
 require 'getoptlong'
+require 'rant/init'
 require 'rant/rantvar'
-require 'rant/rantenv'
 require 'rant/rantsys'
 require 'rant/node'
 require 'rant/import/nodes/default' # could be optimized away
@@ -25,111 +25,16 @@ require 'rant/coregen'
 # this object.
 Rant::MAIN_OBJECT = self
 
-unless Process::Status.method_defined?(:success?) # new in 1.8.2
-    class Process::Status
-        def success?; exitstatus == 0; end
-    end
-end
-unless Regexp.respond_to? :union # new in 1.8.1
-    def Regexp.union(*patterns)
-        # let's hope it comes close to ruby-1.8.1 and upwards...
-        return /(?!)/ if patterns.empty?
-        # i guess the options are lost
-        Regexp.new(patterns.join("|"))
-    end
-end
-if RUBY_VERSION < "1.8.2"
-    class Array
-        undef_method :flatten, :flatten!
-        def flatten
-            cp = self.dup
-            cp.flatten!
-            cp
-        end
-        def flatten!
-            res = []
-            flattened = false
-            self.each { |e|
-                if e.respond_to? :to_ary
-                    res.concat(e.to_ary)
-                    flattened = true
-                else
-                    res << e
-                end
-            }
-            if flattened
-                replace(res)
-                flatten!
-                self
-            end
-        end
-    end
-    if RUBY_VERSION < "1.8.1"
-        module FileUtils
-            undef_method :fu_list
-            def fu_list(arg)
-                arg.respond_to?(:to_ary) ? arg.to_ary : [arg]
-            end
-        end
-    end
-end
-
-class Array
-
-    # Concatenates all elements like #join(' ') but also puts quotes
-    # around strings that contain a space.
-    def arglist
-        warn caller[0]
-        warn "[WARNING] Use `sys.sp(ary)' in Rantfiles instead of deprecated Array#arglist."
-        Rant::Sys.sp(self)
-    end
-
-    def shell_pathes
-        warn caller[0]
-        warn "[WARNING] Array#shell_pathes is highly deprecated " +
-            "and will not come with future (0.5.2 and later) Rant releases."
-        warn "Use `ary.map { |path| sys.sp path }' in Rantfiles."
-        map { |path| Rant::Sys.sp(path) }
-=begin
-	entry = nil
-	if ::Rant::Env.on_windows?
-	    self.collect { |entry|
-		entry = entry.to_s.tr("/", "\\")
-		if entry.include? ' '
-		    '"' + entry + '"'
-		else
-		    entry
-		end
-	    }
-	else
-	    self.collect { |entry|
-		entry = entry.to_s
-		if entry.include? ' '
-		    "'" + entry + "'"
-		else
-		    entry
-		end
-	    }
-	end
-=end
-    end
-end
-
 class String
-    def sub_ext(ext, new_ext = nil)
-	if new_ext
-	    self.sub(/#{Regexp.escape ext}$/, new_ext)
-	else
-	    self.sub(/(\.[^.]*$)|$/, ".#{ext}")
-	end
-    end
+    alias sub_ext _rant_sub_ext
     def to_rant_target
         self
     end
 end
 
+# This module and its methods don't belong to Rant's public API.
+# For (Rant) internal usage only!
 module Rant::Lib
-
     # Parses one string (elem) as it occurs in the array
     # which is returned by caller.
     # E.g.:
@@ -140,21 +45,101 @@ module Rant::Lib
     # Note: This method splits on the pattern <tt>:(\d+)(:|$)</tt>,
     # assuming anything before is the filename.
     def parse_caller_elem(elem)
-	return { :file => "", :ln => 0 } unless elem
-	if elem =~ /^(.+):(\d+)(?::|$)/
-	    { :file => $1, :ln => $2.to_i }
+        return { :file => "", :ln => 0 } unless elem
+        if elem =~ /^(.+):(\d+)(?::|$)/
+            { :file => $1, :ln => $2.to_i }
+        else
+            # should never occur
+            $stderr.puts "parse_caller_elem: #{elem.inspect}"
+            { :file => elem, :ln => 0 }
+        end
+        
+        #parts = elem.split(":")
+        #{ :file => parts[0], :ln => parts[1].to_i }
+    end
+    module_function :parse_caller_elem
+end # module Lib
+
+module Rant::Console
+    RANT_PREFIX		= "rant: "
+    ERROR_PREFIX	= "[ERROR] "
+    WARN_PREFIX		= "[WARNING] "
+    def msg_prefix
+	if defined? @msg_prefix and @msg_prefix
+	    @msg_prefix
 	else
-	    # should never occur
-	    $stderr.puts "parse_caller_elem: #{elem.inspect}"
-	    { :file => elem, :ln => 0 }
+	    RANT_PREFIX
 	end
-	
-	#parts = elem.split(":")
-	#{ :file => parts[0], :ln => parts[1].to_i }
     end
-    module_function :parse_caller_elem
-
-end
+    def msg(*text)
+        pre = msg_prefix
+        $stderr.puts "#{pre}#{text.join("\n" + ' ' * pre.length)}"
+    end
+    def vmsg(importance, *text)
+        msg(*text) if verbose >= importance
+    end
+    def err_msg(*text)
+        pre = msg_prefix + ERROR_PREFIX
+        $stderr.puts "#{pre}#{text.join("\n" + ' ' * pre.length)}"
+    end
+    def warn_msg(*text)
+        pre = msg_prefix + WARN_PREFIX
+        $stderr.puts "#{pre}#{text.join("\n" + ' ' * pre.length)}"
+    end
+    def ask_yes_no text
+        $stderr.print msg_prefix + text + " [y|n] "
+        case $stdin.readline
+        when /y|yes/i: true
+        when /n|no/i: false
+        else
+            $stderr.puts(' ' * msg_prefix.length +
+                "Please answer with `yes' or `no'")
+            ask_yes_no text
+        end
+    end
+    def prompt text
+        $stderr.print msg_prefix + text
+        input = $stdin.readline
+	input ? input.chomp : input
+    end
+    def option_listing opts
+	rs = ""
+	opts.each { |lopt, *opt_a|
+	    if opt_a.size == 2
+		# no short option
+		mode, desc = opt_a
+	    else
+		sopt, mode, desc = opt_a
+	    end
+	    next unless desc	# "private" option
+	    optstr = ""
+	    arg = nil
+	    if mode != GetoptLong::NO_ARGUMENT
+		if desc =~ /(\b[A-Z_]{2,}\b)/
+		    arg = $1
+		end
+	    end
+	    if lopt
+		optstr << lopt
+		if arg
+		    optstr << " " << arg
+		end
+		optstr = optstr.ljust(30)
+	    end
+	    if sopt
+		optstr << "   " unless optstr.empty?
+		optstr << sopt
+		if arg
+		    optstr << " " << arg
+		end
+	    end
+	    rs << "  #{optstr}\n"
+	    rs << "      #{desc.split("\n").join("\n      ")}\n"
+	}
+	rs
+    end
+    extend self
+end # module Rant::Console
 
 # The methods in this module are the public interface to Rant that can
 # be used in Rantfiles.
@@ -217,6 +202,7 @@ module RantContext
         rant.make(*args, &block)
     end
 
+=begin
     # +rac+ stands for "rant compiler"
     def rac
         ch = Rant::Lib.parse_caller_elem caller[0]
@@ -224,6 +210,7 @@ module RantContext
             "Method `rac' is deprecated. Use `rant' instead.")
 	rant
     end
+=end
 end	# module RantContext
 
 class RantAppContext