rant 0.4.8 → 0.5.0

data/lib/rant/rantlib.rb

@@ -40,6 +40,7 @@ unless Regexp.respond_to? :union # new in 1.8.1
 end
 if RUBY_VERSION < "1.8.2"
     class Array
+        undef_method :flatten, :flatten!
         def flatten
             cp = self.dup
             cp.flatten!
@@ -63,11 +64,12 @@ if RUBY_VERSION < "1.8.2"
             end
         end
     end
-end
-if RUBY_VERSION < "1.8.1"
-    module FileUtils
-        def fu_list(arg)
-            arg.respond_to?(:to_ary) ? arg.to_ary : [arg]
+    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
@@ -85,7 +87,7 @@ class Array
     def shell_pathes
         warn caller[0]
         warn "[WARNING] Array#shell_pathes is highly deprecated " +
-            "and will not come with future (0.5.0 and later) Rant releases."
+            "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
@@ -138,8 +140,8 @@ 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 } if elem.nil?
-	if elem =~ /^(.+):(\d+)(:|$)/
+	return { :file => "", :ln => 0 } unless elem
+	if elem =~ /^(.+):(\d+)(?::|$)/
 	    { :file => $1, :ln => $2.to_i }
 	else
 	    # should never occur
@@ -337,6 +339,8 @@ class Rant::RantApp
 	    "Multiple files may be specified with this option." ],
 	[ "--force-run","-a",	GetoptLong::REQUIRED_ARGUMENT,
 	    "Force rebuild of TARGET and all dependencies."     ],
+        [ "--dry-run",  "-n",   GetoptLong::NO_ARGUMENT,
+            "Print info instead of actually executing actions."  ],
 	[ "--tasks",	"-T",	GetoptLong::NO_ARGUMENT,
 	    "Show a list of all described tasks and exit."	],
 	
@@ -449,6 +453,10 @@ class Rant::RantApp
 	    end
 	end
     end
+    def resolve_root_ref(path)
+        return File.join(@rootdir, path[1..-1]) if path =~ /^@/
+        path.sub(/^\\(?=@)/, '')
+    end
     # Returns an absolute path. If path resolves to a directory this
     # method ensures that the returned absolute path doesn't end in a
     # slash.
@@ -860,6 +868,12 @@ class Rant::RantApp
                 @rootdir : @current_subdir})"
             @last_build_subdir = @current_subdir
         end
+        # TODO: model feels sick... this functionality should
+        # be implemented in Node
+        if @opts[:dry_run]
+            task.dry_run
+            true
+        end
     end
 
     private
@@ -958,6 +972,9 @@ class Rant::RantApp
     # of tasks invoked.
     def build(target, opt = {})
 	opt[:force] = true if @force_targets.delete(target)
+        # Currently either the whole application has to by run in
+        # dry-run mode or nothing.
+        opt[:dry_run] = @opts[:dry_run]
 	matching_tasks = 0
 	old_subdir = @current_subdir
 	old_pwd = Dir.pwd
@@ -981,6 +998,8 @@ class Rant::RantApp
     # Currently always returns an array (which might actually be an
     # empty array, but never nil).
     def resolve(task_name, rel_project_dir = @current_subdir)
+        # alternative implementation:
+        #   rec_save_resolve(task_name, nil, rel_project_dir)
 	s = @tasks[expand_path(rel_project_dir, task_name)]
 	case s
 	when nil
@@ -1004,6 +1023,23 @@ class Rant::RantApp
     end
     public :resolve
 
+    def rec_save_resolve(task_name, excl_hook, rel_project_dir = @current_subdir)
+	s = @tasks[expand_path(rel_project_dir, task_name)]
+	case s
+	when nil
+	    @resolve_hooks.each { |s|
+                next if s == excl_hook
+		s = s[task_name, rel_project_dir]
+		return s if s
+	    }
+	    []
+	when Rant::Node: [s]
+	else
+	    s
+	end
+    end
+    public :rec_save_resolve
+
     # This hook will be invoked when no matching task is found for a
     # target. It may create one or more tasks for the target, which is
     # given as argument, on the fly and return an array of the created

data/lib/rant/rantsys.rb

@@ -125,6 +125,12 @@ module Rant
 	    @files.size
 	end
 
+        alias _object_respond_to? respond_to?
+        private :_object_respond_to?
+        def respond_to?(msg)
+            _object_respond_to?(msg) or @files.respond_to?(msg)
+        end
+
 	def method_missing(sym, *args, &block)
 	    if @files.respond_to? sym
 		resolve if @pending
@@ -324,55 +330,6 @@ end
 	end
 	private :apply_no_dir
 
-	# Remove all files which have the given name.
-	def no_file(name)
-            @actions << [:apply_ary_method, :reject!,
-                lambda { |entry|
-                    entry == name && !@keep[entry] && test(?f, entry)
-                }]
-	    @pending = true
-	    self
-	end
-
-	# Remove all entries which contain an element
-	# with the given suffix.
-	def no_suffix(suffix)
-	    @actions << [:no_suffix, suffix]
-	    @pending = true
-	    self
-	end
-
-	def apply_no_suffix(suffix)
-	    elems =  nil
-	    elem = nil
-	    @files.reject! { |entry|
-		elems = Sys.split_all(entry)
-		elems.any? { |elem|
-		    elem =~ /#{suffix}$/ && !@keep[entry]
-		}
-	    }
-	end
-	private :apply_no_suffix
-
-	# Remove all entries which contain an element
-	# with the given prefix.
-	def no_prefix(prefix)
-	    @actions << [:no_prefix, prefix]
-	    @pending = true
-	    self
-	end
-
-	def apply_no_prefix(prefix)
-	    elems = elem = nil
-	    @files.reject! { |entry|
-		elems = Sys.split_all(entry)
-		elems.any? { |elem|
-		    elem =~ /^#{prefix}/ && !@keep[entry]
-		}
-	    }
-	end
-	private :apply_no_prefix
-
 	# Get a string with all entries. This is very usefull
 	# if you invoke a shell:
 	#	files # => ["foo/bar", "with space"]
@@ -417,6 +374,11 @@ end
         def apply_ary_method_1(meth, arg1, block=nil)
             @files.send meth, arg1, &block
         end
+=begin
+        def apply_lazy_operation(meth, args, block)
+            @files.send(meth, *args, &block)
+        end
+=end
     end	# class FileList
 
     class RacFileList < FileList
@@ -645,19 +607,25 @@ end
 
 	# If supported, make a hardlink, otherwise
 	# fall back to copying.
-	def safe_ln(*args)
+	def safe_ln(src, dest)
+            dest = dest.to_str
+            src = src.respond_to?(:to_ary) ? src.to_ary : src.to_str
 	    unless Sys.symlink_supported
-		cp(*args)
+		cp(src, dest)
 	    else
 		begin
-		    ln(*args)
-		rescue Exception #Errno::EOPNOTSUPP
+		    ln(src, dest)
+		rescue Exception # SystemCallError # Errno::EOPNOTSUPP
 		    Sys.symlink_supported = false
-		    cp(*args)
+		    cp(src, dest)
 		end
 	    end
 	end
 
+        def ln_f(src, dest)
+            ln(src, dest, :force => true)
+        end
+
 	# Split a path in all elements.
 	def split_all(path)
 	    base, last = File.split(path)

data/lib/rant/rantvar.rb

@@ -15,8 +15,9 @@
 #
 # If you're looking for general info about Rant, read the
 # README[link:files/README.html].
+
 module Rant
-    VERSION = '0.4.8'
+    VERSION = '0.5.0'
 
     # Those are the filenames for rantfiles.
     # Case matters!
@@ -115,7 +116,7 @@ module Rant
 		# holds constraints for values in @store
 		@constraints = {}
 		# set by default query
-		@current_var = nil
+		@current_var = nil # this line will go in 0.5.4
 	    end
 
 	    def query(*args, &block)
@@ -128,7 +129,7 @@ module Rant
 		    if Hash === arg
 			if arg.size == 1
 			    arg.each { |k,v|
-				@current_var = k
+				@current_var = k # this line will go in 0.5.4
 				self[k] = v if self[k].nil?
 			    }
 			    self
@@ -138,16 +139,21 @@ module Rant
 		    else
 			self[arg]
 		    end
-		when 2..3
-		    @current_var, cf, val = *args
-		    self.is cf
-		    self[@current_var] = val if val
+		when 2, 3
+		    vid, cf, val = *args
+                    @current_var = vid # this line will go in 0.5.4
+                    constrain vid,
+                        get_factory(cf).rant_constraint
+		    self[vid] = val if val
 		else
-		    raise QueryError, "to many arguments"
+		    raise QueryError, "too many arguments"
 		end
 	    end
 
 	    def is ct, *ct_args
+                warn caller[0]
+                warn "method `var.is' is deprecated and will not be " +
+                    "in Rant 0.5.4 and later"
 		constrain @current_var,
 		    get_factory(ct).rant_constraint(*ct_args)
 		self
@@ -166,13 +172,53 @@ module Rant
 	    def get_factory id
 		if String === id || Symbol === id
 		    begin
+                        ### temporary solution ###
+                        raise unless Constraints.const_defined? id
+                        ##########################
 			id = Constraints.const_get(id)
 		    rescue
-			raise NotAConstraintFactoryError.new(id), caller
+                        ### temporary solution ###
+                        id_sym = id.to_sym
+                        rl =
+                        if [:Integer, :IntegerInRange, :Float,
+                            :FloatInRange].include? id_sym
+                            'rant/import/var/numbers'
+                        elsif [:Bool, :BoolTrue].include? id_sym
+                            'rant/import/var/booleans'
+                        elsif :List == id_sym
+                            'rant/import/var/lists'
+                        elsif [:String, :ToString].include? id_sym
+                            'rant/import/var/strings'
+                        else
+                        ##########################
+                            raise NotAConstraintFactoryError.new(id), caller
+                        end
+                        warn "Explicitely <code>import " +
+                            "'#{rl.sub(/^rant\/import\//, '')}'" +
+                            "</code> to use the #{id_sym.inspect} " +
+                            "constraint."
+                        require rl #rant-import:remove
+                        retry
 		    end
 		end
 		unless id.respond_to? :rant_constraint
-		    raise NotAConstraintFactoryError.new(id), caller
+                    ### temporary solution ###
+                    rl =
+                    if id == true || id == false
+                        'rant/import/var/booleans'
+                    elsif id == String
+                        'rant/import/var/strings'
+                    elsif id.kind_of? Range
+                        'rant/import/var/numbers'
+                    else
+                    ##########################
+                        raise NotAConstraintFactoryError.new(id), caller
+                    end
+                    warn "Explicitely <code>import " +
+                        "'#{rl.sub(/^rant\/import\//, '')}'" +
+                        "</code> to use the #{id.inspect} " +
+                        "constraint."
+                    require rl #rant-import:remove
 		end
 		id
 	    end
@@ -278,237 +324,6 @@ module Rant
 	    end
 	end
 
-	module Constraints
-
-	    class String
-		include Constraint
-
-		class << self
-		    alias rant_constraint new
-		end
-
-		def filter(val)
-		    if val.respond_to? :to_str
-			val.to_str
-		    elsif Symbol === val
-			val.to_s
-		    else
-			raise ConstraintError.new(self, val)
-		    end
-		end
-		def default
-		    ""
-		end
-		def to_s
-		    "string"
-		end
-	    end
-
-	    class ToString < String
-		class << self
-		    alias rant_constraint new
-		end
-		def filter(val)
-		    val.to_s
-		end
-	    end
-
-	    class Integer
-		include Constraint
-
-		class << self
-		    def rant_constraint(range = nil)
-			if range
-			    IntegerInRange.new(range)
-			else
-			    self.new
-			end
-		    end
-		end
-
-		def filter(val)
-		    Kernel::Integer(val)
-		rescue
-		    raise ConstraintError.new(self, val)
-		end
-		def default
-		    0
-		end
-		def to_s
-		    "integer"
-		end
-	    end
-
-	    class IntegerInRange < Integer
-		def initialize(range)
-		    @range = range
-		end
-		def filter(val)
-		    i = super
-		    if @range === i
-			i
-		    else
-			raise ConstraintError.new(self, val)
-		    end
-		end
-		def default
-		    @range.min
-		end
-		def to_s
-		    super + " #{@range}"
-		end
-	    end
-
-	    class Float
-		include Constraint
-
-		class << self
-		    def rant_constraint(range = nil)
-			if range
-			    FloatInRange.new(range)
-			else
-			    self.new
-			end
-		    end
-		end
-
-		def filter(val)
-		    Kernel::Float(val)
-		rescue
-		    raise ConstraintError.new(self, val)
-		end
-		def default
-		    0.0
-		end
-		def to_s
-		    "float"
-		end
-	    end
-
-	    class FloatInRange < Float
-		def initialize(range)
-		    @range = range
-		end
-		def filter(val)
-		    i = super
-		    if @range === i
-			i
-		    else
-			raise ConstraintError.new(self, val)
-		    end
-		end
-		def default
-		    @range.first
-		end
-		def to_s
-		    super + " #{@range}"
-		end
-	    end
-
-	    class AutoList
-		include Constraint
-
-		class << self
-		    alias rant_constraint new
-		end
-
-		def filter(val)
-		    if val.respond_to? :to_ary
-			val.to_ary
-		    elsif val.nil?
-			raise ConstraintError.new(self, val)
-		    else
-			[val]
-		    end
-		end
-		def default
-		    []
-		end
-		def to_s
-		    "list or single, non-nil value"
-		end
-	    end
-
-	    class List
-		include Constraint
-
-		class << self
-		    alias rant_constraint new
-		end
-
-		def filter(val)
-		    if val.respond_to? :to_ary
-			val.to_ary
-		    else
-			raise ConstraintError.new(self, val)
-		    end
-		end
-		def default
-		    []
-		end
-		def to_s
-		    "list (Array)"
-		end
-	    end
-
-	    Array = List
-
-	    class Bool
-		include Constraint
-		class << self
-		    alias rant_constraint new
-		end
-		def filter(val)
-		    if ::Symbol === val or ::Integer === val
-			val = val.to_s
-		    end
-		    if val == true
-			true
-		    elsif val == false || val == nil
-			false
-		    elsif val.respond_to? :to_str
-			case val.to_str
-			when /^\s*true\s*$/i:	true
-			when /^\s*false\s*$/i:	false
-			when /^\s*y(es)?\s*$/i:	true
-			when /^\s*n(o)?\s*$/:	false
-			when /^\s*on\s*$/i:	true
-			when /^\s*off\s*$/i:	false
-			when /^\s*1\s*$/:	true
-			when /^\s*0\s*$/:	false
-			else
-			    raise ConstraintError.new(self, val)
-			end
-		    else
-			raise ConstraintError.new(self, val)
-		    end
-		end
-		def default
-		    false
-		end
-		def to_s
-		    "bool"
-		end
-	    end
-
-	    class BoolTrue < Bool
-		def default
-		    true
-		end
-	    end
-
-	    #--
-	    # perhaps this should stay a secret ;)
-	    #++
-	    def true.rant_constraint
-		BoolTrue.rant_constraint
-	    end
-	    def false.rant_constraint
-		Bool.rant_constraint
-	    end
-
-	end	# module Constraints
-
 	# A +vid+ has to be a String to be valid.
 	def valid_vid(obj)
 	    case obj
@@ -537,18 +352,36 @@ module Rant
 	end
 
 	module_function :valid_constraint?, :valid_vid
-    end	# module RantVar
-end	# module Rant
-
-class Range
-    def rant_constraint
-        case first
-        when ::Integer
-            Rant::RantVar::Constraints::IntegerInRange.new(self)
-        when ::Float
-            Rant::RantVar::Constraints::FloatInRange.new(self)
-        else
-            raise NotAConstraintFactoryError.new(self)
-        end
-    end
-end
+
+	module Constraints
+	    class AutoList
+		include Constraint
+		class << self
+		    alias rant_constraint new
+		end
+		def filter(val)
+		    if val.respond_to? :to_ary
+			val.to_ary
+		    elsif val.nil?
+			raise ConstraintError.new(self, val)
+		    else
+			[val]
+		    end
+		end
+		def default
+		    []
+		end
+		def to_s
+		    "list or single, non-nil value"
+		end
+	    end
+        end # module Constraints
+    end # module RantVar
+end # module Rant
+
+### temporary solution ###
+#require 'rant/import/var/numbers' #rant-import:uncomment
+#require 'rant/import/var/booleans' #rant-import:uncomment
+#require 'rant/import/var/lists' #rant-import:uncomment
+#require 'rant/import/var/strings' #rant-import:uncomment
+##########################

data/misc/TODO

@@ -1,6 +1,24 @@
 
 = TODO
 
+== Convinient symlink method
+
+Implement a Rant::Sys.symlink (or similar name) method that converts
+destination filenames to absolute pathes before actual linking.
+
+== More tests for --dry-run
+
+== Behaviour of `gen Rule' without block
+
+Currently dies with <tt>undefined method `arity' for
+nil:NilClass</tt>.
+
+Done (0.4.9), printing an appropriate error message.
+
+== Command: Hash interpolation
+
+Decide about behaviour of hash interpolation in Command tasks.
+
 == Don't use +invoke+ result of dependency to check if update is
    necessary
 

data/misc/devel-notes

@@ -1,6 +1,31 @@
 
+== Rule recursion
+
+Since Rant 0.4.9, rules created with <tt>gen Rule</tt> no longer
+recurse. This means, that when looking for the Rule's source(s), this
+specific rule itself is ignored. This prevents infinite recursion.
+
+Consider:
+
+    gen Rule, "o" => ".foo" do something end
+
+Say we call <tt>make "bo"</tt>.
+
+Rant pre 0.4.9 behaviour:
+
+The rule matches anything ending in "o". Since "bo" ends in "o", the
+rule matches and searches for the source "b.foo". No task is defined
+for "b.foo", but again our only rule matches and thus searches for the
+source "b.fo.foo". Now we have our infinite recursion.
+
+Rant 0.4.9 and later behaviour:
+
+The only rule matches and searches for the source "b.foo". When a rule
+searches for a source, the rule itself is excluded. No infinite
+recursion.
+
 == Rant::Env.find_bin...
-... could honour PATHEXT on windows.
+... should honour PATHEXT on windows.
 
 == Task alias
 Since +alias+ is a Ruby keyword, we could use +nick+ to create task

data/test/action.rant

@@ -0,0 +1,24 @@
+
+import "sys/more"
+
+gen Action, /\.t$/ do
+    puts 'executing action: rx /\.t$/'
+    source "action.t.rant"
+end
+
+file "action.t.rant" do |t|
+    sys.write_to_file t.name, <<-EOF
+    file "a.t" do |t|
+        sys.touch t.name
+    end
+    file "b.t" do |t|
+        sys.touch t.name
+    end
+    EOF
+end
+
+file "b.tt" do |t|
+    sys.touch t.name
+end
+
+subdirs "sub.t" if test ?d, "sub.t"