From 52f8b9c0b1e1606a4260ef2e0df4d525497691b1 Mon Sep 17 00:00:00 2001
From: Ralph Amissah <ralph@amissah.com>
Date: Sat, 7 Jul 2007 09:21:47 +0100
Subject: cgi-sample search form; texinfo fix; xml scaffold; help, man pages
etc. visited; screen output, color set to true; docbook entries removed
* cgi generated sample search form
* order results on files of the same title, in multiple files (with
different filenames)
* postgresql, character case sensitivity, control, on/off
* tail decoration, gplv3 & sisu info
* texinfo/info (pinfo) module starts to do something vaguely useful again
[not a much used module, testing required]
* print XML rendition of document structure to screen -T
* sisurc.yml default, color set to true
[apologies if this causes anyone any inconvenience, it is configurable in
sisurc.yml]
* help, man pages, README (man(8) related and env, 'sisu -V')
* docbook entries removed for the present time
* sisu-install (install ruby rant script renamed) and permissions set to
executable
---
install | 3088 ---------------------------------------------------------------
1 file changed, 3088 deletions(-)
delete mode 100644 install
(limited to 'install')
diff --git a/install b/install
deleted file mode 100644
index 78ad16a4..00000000
--- a/install
+++ /dev/null
@@ -1,3088 +0,0 @@
-#!/usr/bin/env ruby
-
-# install - Monolithic rant script, autogenerated by rant-import 0.5.8.
-#
-# Copyright (C) 2005 Stefan Lang <langstefan@gmx.at>
-#
-# This program is free software.
-# You can distribute/modify this program under the terms of
-# the GNU LGPL, Lesser General Public License version 2.1.
-
-
-require 'getoptlong'
-
-
-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)
- 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.8'
-
- @__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
- def pathes
- path = ENV[on_windows? ? "Path" : "PATH"]
- return [] unless path
- path.split(on_windows? ? ";" : ":")
- end
- 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
- def shell_path path
- 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
- def sp(arg)
- if arg.respond_to? :to_ary
- arg.to_ary.map{ |e| sp e }.join(' ')
- else
- _escaped_path arg
- end
- end
- 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
- 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
-
-
- ROOT_RANTFILE = "root.rant"
- SUB_RANTFILE = "sub.rant"
- RANTFILES = [ "Rantfile", "rantfile", ROOT_RANTFILE ]
-
- CODE_IMPORTS = []
-
- class RantAbortException < StandardError
- end
-
- class RantDoneException < StandardError
- end
-
- class Error < StandardError
- end
-
- module Generators
- end
-
- module RantVar
-
- class Error < Rant::Error
- end
-
- class ConstraintError < Error
-
- attr_reader :constraint, :val
-
- def initialize(constraint, val, msg = nil)
- @msg = msg
- @constraint = constraint
- @val = val
- end
-
- def message
- val_desc = @val.inspect
- val_desc[7..-1] = "..." if val_desc.length > 10
- "#{val_desc} doesn't match constraint: #@constraint"
- end
- end
-
- class NotAConstraintFactoryError < Error
- attr_reader :obj
- def initialize(obj, msg = nil)
- @msg = msg
- @obj = obj
- end
- def message
- obj_desc = @obj.inspect
- obj_desc[7..-1] = "..." if obj_desc.length > 10
- "#{obj_desc} is not a valid constraint factory"
- end
- end
-
- class InvalidVidError < Error
- def initialize(vid, msg = nil)
- @msg = msg
- @vid = vid
- end
- def message
- vid_desc = @vid.inspect
- vid_desc[7..-1] = "..." if vid_desc.length > 10
- "#{vid_desc} is not a valid var identifier"
- end
- end
-
- class InvalidConstraintError < Error
- end
-
- class QueryError < Error
- end
-
- class Space
-
- @@env_ref = Object.new
-
- def initialize
- @store = {}
- @constraints = {}
- end
-
- def query(*args, &block)
- case args.size
- when 0
- raise QueryError, "no arguments", caller
- when 1
- arg = args.first
- if Hash === arg
- if arg.size == 1
- arg.each { |k,v|
- self[k] = v if self[k].nil?
- }
- self
- else
- init_all arg
- end
- else
- self[arg]
- end
- when 2, 3
- vid, cf, val = *args
- constrain vid,
- get_factory(cf).rant_constraint
- self[vid] = val if val
- else
- raise QueryError, "too many arguments"
- end
- end
-
- def restrict vid, ct, *ct_args
- if vid.respond_to? :to_ary
- vid.to_ary.each { |v| restrict(v, ct, *ct_args) }
- else
- constrain vid,
- get_factory(ct).rant_constraint(*ct_args)
- end
- self
- end
-
- def get_factory id
- if String === id || Symbol === id
- id = Constraints.const_get(id) rescue nil
- end
- unless id.respond_to? :rant_constraint
- raise NotAConstraintFactoryError.new(id), caller
- end
- id
- end
- private :get_factory
-
- def [](vid)
- vid = RantVar.valid_vid vid
- val = @store[vid]
- val.equal?(@@env_ref) ? ENV[vid] : val
- end
-
- def []=(vid, val)
- vid = RantVar.valid_vid(vid)
- c = @constraints[vid]
- if @store[vid] == @@env_ref
- ENV[vid] = c ? c.filter(val) : val
- else
- @store[vid] = c ? c.filter(val) : val
- end
- end
-
- def env(*vars)
- vars.flatten.each { |var|
- vid = RantVar.valid_vid(var)
- cur_val = @store[vid]
- next if cur_val == @@env_ref
- ENV[vid] = cur_val unless cur_val.nil?
- @store[vid] = @@env_ref
- }
- nil
- end
-
- def set_all hash
- unless Hash === hash
- raise QueryError,
- "set_all argument has to be a hash"
- end
- hash.each_pair { |k, v|
- self[k] = v
- }
- end
-
- def init_all hash
- unless Hash === hash
- raise QueryError,
- "init_all argument has to be a hash"
- end
- hash.each_pair { |k, v|
- self[k] = v if self[k].nil?
- }
- end
-
- def constrain vid, constraint
- vid = RantVar.valid_vid(vid)
- unless RantVar.valid_constraint? constraint
- raise InvalidConstraintError, constraint
- end
- @constraints[vid] = constraint
- if @store.member? vid
- begin
- val = @store[vid]
- @store[vid] = constraint.filter(@store[vid])
- rescue
- @store[vid] = constraint.default
- raise ConstraintError.new(constraint, val)
- end
- else
- @store[vid] = constraint.default
- end
- end
-
- def has_var?(vid)
- !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
- def matches? val
- filter val
- true
- rescue
- return false
- end
- end
-
- def valid_vid(obj)
- case obj
- when String; obj
- when Symbol; obj.to_s
- else
- if obj.respond_to? :to_str
- obj.to_str
- else
- raise InvalidVidError.new(obj)
- end
- end
- end
-
- def valid_constraint?(obj)
- obj.respond_to?(:filter) &&
- obj.respond_to?(:matches?) &&
- obj.respond_to?(:default)
- end
-
- module_function :valid_constraint?, :valid_vid
-
- 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
-
-
-require 'fileutils'
-
-
-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)
- 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
- h_keep = {}
- @keep.each_key { |entry| h_keep[entry] = true }
- c.instance_variable_set(:@keep, h_keep)
- c
- end
- def glob_dotfiles?
- @def_glob_dotfiles
- end
- def glob_dotfiles=(flag)
- @def_glob_dotfiles = flag ? true : false
- end
- def hide_dotfiles
- @def_glob_dotfiles = false
- self
- end
- 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
- def <<(file)
- @actions << [:apply_ary_method_1, :push, file]
- @keep[file] = true
- @pending = true
- self
- end
- def keep(entry)
- @keep[entry] = true
- @items << entry
- self
- end
- 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
- 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
- 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
- def include(*pats)
- @def_glob_dotfiles ? glob_all(*pats) : glob_unix(*pats)
- end
- alias glob include
- 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"
- 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)
- 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
- 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
- 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
- def arglist
- Rant::Sys.sp to_ary
- end
- alias to_s arglist
- alias object_inspect inspect
- def uniq!
- @actions << [:apply_ary_method, :uniq!]
- @pending = true
- self
- end
- def sort!
- @actions << [:apply_ary_method, :sort!]
- @pending = true
- self
- end
- 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
- end # class FileList
-end # module Rant
-
-if RUBY_VERSION == "1.8.3"
- module FileUtils
- METHODS = singleton_methods - %w(private_module_function
- commands options have_option? options_of collect_method)
- module Verbose
- class << self
- public(*::FileUtils::METHODS)
- end
- public(*::FileUtils::METHODS)
- 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
-
-module Rant
- class RacFileList < FileList
-
- attr_reader :subdir
- attr_reader :basedir
-
- def initialize(rac, store = [])
- super(store)
- @rac = rac
- @subdir = @rac.current_subdir
- @basedir = Dir.pwd
- @ignore_hash = nil
- @add_ignore_args = []
- update_ignore_rx
- end
- def dup
- c = super
- c.instance_variable_set(
- :@add_ignore_args, @add_ignore_args.dup)
- c
- end
- def copy
- c = super
- c.instance_variable_set(
- :@add_ignore_args, @add_ignore_args.map { |e| e.dup })
- c
- end
- alias filelist_ignore ignore
- def ignore(*patterns)
- @add_ignore_args.concat patterns
- self
- end
- def ignore_rx
- update_ignore_rx
- @ignore_rx
- end
- alias filelist_resolve resolve
- def resolve
- Sys.cd(@basedir) { filelist_resolve }
- end
- def each_cd(&block)
- old_pwd = Dir.pwd
- Sys.cd(@basedir)
- filelist_resolve if @pending
- @items.each(&block)
- ensure
- Sys.cd(old_pwd)
- 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
- filelist_ignore(*ri)
- @ignore_hash = rh
- end
- end
- end # class RacFileList
-
- class MultiFileList
-
- attr_reader :cur_list
-
- def initialize(rac)
- @rac = rac
- @cur_list = RacFileList.new(@rac)
- @lists = [@cur_list]
- end
-
- def each_entry(&block)
- @lists.each { |list|
- list.each_cd(&block)
- }
- end
-
- def add(filelist)
- @cur_list = filelist
- @lists << filelist
- self
- end
-
- def method_missing(sym, *args, &block)
- if @cur_list && @cur_list.respond_to?(sym)
- if @cur_list.subdir == @rac.current_subdir
- @cur_list.send(sym, *args, &block)
- else
- add(RacFileList.new(@rac))
- @cur_list.send(sym, *args, &block)
- end
- else
- super
- end
- end
- end # class MultiFileList
-
- class CommandError < StandardError
- attr_reader :cmd
- attr_reader :status
- def initialize(cmd, status=nil, msg=nil)
- @msg = msg
- @cmd = cmd
- @status = status
- end
- def message
- if !@msg && cmd
- if status
- "Command failed with status #{status.exitstatus}:\n" +
- "[#{cmd}]"
- else
- "Command failed:\n[#{cmd}]"
- end
- else
- @msg
- end
- end
- end
-
- module Sys
- include ::FileUtils::Verbose
-
- @symlink_supported = true
- class << self
- attr_accessor :symlink_supported
- end
-
- def fu_output_message(msg) #:nodoc:
- 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
-
- def sh(*cmd_args, &block)
- cmd_args.flatten!
- cmd = cmd_args.join(" ")
- fu_output_message cmd
- success = system(*cmd_args)
- if block_given?
- block[$?]
- elsif !success
- raise CommandError.new(cmd, $?)
- end
- end
-
- def ruby(*args, &block)
- if args.empty?
- sh(Env::RUBY_EXE, '', &block)
- else
- sh(args.unshift(Env::RUBY_EXE), &block)
- end
- end
- def cd(dir, &block)
- fu_output_message "cd #{dir}"
- orig_pwd = Dir.pwd
- Dir.chdir dir
- if block
- begin
- block.arity == 0 ? block.call : block.call(Dir.pwd)
- ensure
- fu_output_message "cd -"
- Dir.chdir orig_pwd
- end
- else
- self
- end
- end
-
- 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(src, dest)
- else
- begin
- ln(src, dest)
- rescue Exception # SystemCallError # Errno::EOPNOTSUPP
- Sys.symlink_supported = false
- cp(src, dest)
- end
- end
- end
-
- def ln_f(src, dest)
- ln(src, dest, :force => true)
- end
-
- def split_path(str)
- str.split(Env.on_windows? ? ";" : ":")
- end
-
- if Env.on_windows?
- def root_dir?(path)
- path == "/" || path == "\\" ||
- path =~ %r{\A[a-zA-Z]+:(\\|/)\Z}
- end
- def absolute_path?(path)
- path =~ %r{\A([a-zA-Z]+:)?(/|\\)}
- end
- else
- def root_dir?(path)
- path == "/"
- end
- def absolute_path?(path)
- path =~ %r{\A/}
- end
- end
-
- extend self
-
- if RUBY_VERSION >= "1.8.4" # needed by 1.9.0, too
- class << self
- public(*::FileUtils::METHODS)
- end
- public(*::FileUtils::METHODS)
- end
-
- end # module Sys
-
- class SysObject
- include Sys
- def initialize(rant)
- @rant = rant or
- raise ArgumentError, "rant application required"
- end
- def ignore(*patterns)
- @rant.var[:ignore].concat(patterns)
- nil
- end
- def filelist(arg = Rant.__rant_no_value__)
- if Rant.__rant_no_value__.equal?(arg)
- RacFileList.new(@rant)
- elsif arg.respond_to?(:to_rant_filelist)
- arg.to_rant_filelist
- elsif arg.respond_to?(:to_ary)
- RacFileList.new(@rant, arg.to_ary)
- else
- raise TypeError,
- "cannot convert #{arg.class} into Rant::FileList"
- end
- end
- def [](*patterns)
- RacFileList.new(@rant).hide_dotfiles.include(*patterns)
- end
- def glob(*patterns, &block)
- fl = RacFileList.new(@rant).hide_dotfiles.include(*patterns)
- fl.ignore(".", "..")
- if block_given? then yield fl else fl end
- end
- def glob_all(*patterns, &block)
- fl = RacFileList.new(@rant).include(*patterns)
- fl.ignore(".", "..") # use case: "*.*" as pattern
- if block_given? then yield fl else fl end
- end
- def expand_path(path)
- File.expand_path(@rant.project_to_fs_path(path))
- end
- private
- def fu_output_message(cmd)
- @rant.cmd_msg cmd
- end
- end
-
-
- class TaskFail < StandardError
- def initialize(task, orig, msg)
- @task = task
- @orig = orig
- @msg = msg
- end
- def exception
- self
- end
- def task
- @task
- end
- def tname
- @task ? @task.name : nil
- end
- def orig
- @orig
- end
- def msg
- @msg
- end
- end
-
- class Rantfile
- attr_reader :tasks, :path
- attr_accessor :project_subdir
- def initialize(path)
- @path = path or raise ArgumentError, "path required"
- @tasks = []
- @project_subdir = nil
- end
- alias to_s path
- alias to_str path
- end # class Rantfile
-
- module Node
-
- INVOKE_OPT = {}.freeze
-
- T0 = Time.at(0).freeze
-
- attr_reader :name
- attr_reader :rac
- attr_accessor :description
- attr_accessor :rantfile
- attr_accessor :line_number
- attr_accessor :project_subdir
-
- def initialize
- @description = nil
- @rantfile = nil
- @line_number = nil
- @run = false
- @project_subdir = ""
- @success = nil
- end
-
- def reference_name
- sd = rac.current_subdir
- case sd
- when ""; full_name
- when project_subdir; name
- else "@#{full_name}".sub(/^@#{Regexp.escape sd}\//, '')
- end
- end
-
- alias to_s reference_name
- alias to_rant_target name
-
- def full_name
- sd = project_subdir
- sd.empty? ? name : File.join(sd, name)
- end
-
- def ch
- {:file => rantfile.to_str, :ln => line_number}
- end
-
- def goto_task_home
- @rac.goto_project_dir project_subdir
- end
-
- def file_target?
- false
- end
-
- def done?
- @success
- end
-
- def needed?
- invoke(:needed? => true)
- end
-
- def run?
- @run
- end
-
- def invoke(opt = INVOKE_OPT)
- return circular_dep if run?
- @run = true
- begin
- return !done? if opt[:needed?]
- self.run if !done?
- @success = true
- ensure
- @run = false
- end
- end
-
- def fail msg = nil, orig = nil
- raise TaskFail.new(self, orig, msg)
- end
-
- def each_target
- end
-
- def has_actions?
- defined? @block and @block
- end
-
- def dry_run
- text = "Executing #{name.dump}"
- text << " [NOOP]" unless has_actions?
- @rac.cmd_msg text
- action_descs.each { |ad|
- @rac.cmd_print " - "
- @rac.cmd_msg ad.sub(/\n$/, '').gsub(/\n/, "\n ")
- }
- end
-
- private
- def run
- goto_task_home
- return if @rac.running_task(self)
- return unless has_actions?
- @receiver.pre_run(self) if defined? @receiver and @receiver
- @block.arity == 0 ? @block.call : @block[self] if @block
- end
-
- def action_descs
- descs = []
- if defined? @receiver and @receiver
- descs.concat(@receiver.pre_action_descs)
- end
- @block ? descs << action_block_desc : descs
- end
-
- def action_block_desc
- @block.inspect =~ /^#<Proc:[\da-z]+@(.+):(\d+)>$/i
- fn, ln = $1, $2
- "Ruby Proc at #{fn.sub(/^#{Regexp.escape @rac.rootdir}\//, '')}:#{ln}"
- end
-
- def circular_dep
- rac.warn_msg "Circular dependency on task `#{full_name}'."
- false
- end
- end # module Node
-
-
- def self.init_import_nodes__default(rac, *rest)
- rac.node_factory = DefaultNodeFactory.new
- end
-
- class DefaultNodeFactory
- def new_task(rac, name, pre, blk)
- Task.new(rac, name, pre, &blk)
- end
- def new_file(rac, name, pre, blk)
- FileTask.new(rac, name, pre, &blk)
- end
- def new_dir(rac, name, pre, blk)
- DirTask.new(rac, name, pre, &blk)
- end
- def new_source(rac, name, pre, blk)
- SourceNode.new(rac, name, pre, &blk)
- end
- def new_custom(rac, name, pre, blk)
- UserTask.new(rac, name, pre, &blk)
- end
- def new_auto_subfile(rac, name, pre, blk)
- AutoSubFileTask.new(rac, name, pre, &blk)
- end
- end
-
- class Task
- include Node
-
- attr_accessor :receiver
-
- def initialize(rac, name, prerequisites = [], &block)
- super()
- @rac = rac or raise ArgumentError, "rac not given"
- @name = name or raise ArgumentError, "name not given"
- @pre = prerequisites || []
- @pre_resolved = false
- @block = block
- @run = false
- @receiver = nil
- end
-
- def prerequisites
- @pre.collect { |pre| pre.to_s }
- end
- alias deps prerequisites
-
- def source
- @pre.first.to_s
- end
-
- def has_actions?
- @block or @receiver && @receiver.has_pre_action?
- end
-
- def <<(pre)
- @pre_resolved = false
- @pre << pre
- end
-
- def invoked?
- !@success.nil?
- end
-
- def fail?
- @success == false
- end
-
- def enhance(deps = nil, &blk)
- if deps
- @pre_resolved = false
- @pre.concat deps
- end
- if @block
- if blk
- first_block = @block
- @block = lambda { |t|
- first_block[t]
- blk[t]
- }
- end
- else
- @block = blk
- end
- end
-
- def invoke(opt = INVOKE_OPT)
- return circular_dep if @run
- @run = true
- begin
- return if done?
- internal_invoke opt
- ensure
- @run = false
- end
- end
-
- def internal_invoke(opt, ud_init = true)
- goto_task_home
- update = ud_init || opt[:force]
- dep = nil
- uf = false
- each_dep { |dep|
- if dep.respond_to? :timestamp
- handle_timestamped(dep, opt) && update = true
- elsif Node === dep
- handle_node(dep, opt) && update = true
- else
- dep, uf = handle_non_node(dep, opt)
- uf && update = true
- dep
- end
- }
- if @receiver
- goto_task_home
- update = true if @receiver.update?(self)
- end
- return update if opt[:needed?]
- run if update
- @success = true
- update
- rescue StandardError => e
- @success = false
- self.fail(nil, e)
- end
- private :internal_invoke
-
- def handle_node(dep, opt)
- dep.invoke opt
- end
-
- def handle_timestamped(dep, opt)
- dep.invoke opt
- end
-
- def handle_non_node(dep, opt)
- @rac.err_msg "Unknown task `#{dep}',",
- "referenced in `#{rantfile.path}', line #{@line_number}!"
- self.fail
- end
-
- def each_dep
- t = nil
- if @pre_resolved
- return @pre.each { |t| yield(t) }
- end
- my_full_name = full_name
- my_project_subdir = project_subdir
- @pre.map! { |t|
- if Node === t
- if t.full_name == my_full_name
- nil
- else
- yield(t)
- t
- end
- else
- t = t.to_s if Symbol === t
- if t == my_full_name #TODO
- nil
- else
- selection = @rac.resolve t,
- my_project_subdir
- if selection.empty?
- yield(t)
- else
- selection.each { |st| yield(st) }
- selection
- end
- end
- end
- }
- if @pre.kind_of? Rant::FileList
- @pre.resolve
- else
- @pre.flatten!
- @pre.compact!
- end
- @pre_resolved = true
- end
- end # class Task
-
- class UserTask < Task
-
- def initialize(*args)
- super
- @block = nil
- @needed = nil
- @target_files = nil
- yield self if block_given?
- end
-
- def act(&block)
- @block = block
- end
-
- def needed(&block)
- @needed = block
- end
-
- def file_target?
- @target_files and @target_files.include? @name
- end
-
- def each_target(&block)
- goto_task_home
- @target_files.each(&block) if @target_files
- end
-
- def file_target(*args)
- args.flatten!
- args << @name if args.empty?
- if @target_files
- @target_files.concat(args)
- else
- @target_files = args
- end
- end
-
- def invoke(opt = INVOKE_OPT)
- return circular_dep if @run
- @run = true
- begin
- return if done?
- internal_invoke(opt, ud_init_by_needed)
- ensure
- @run = false
- end
- end
-
- private
- def ud_init_by_needed
- if @needed
- goto_task_home
- @needed.arity == 0 ? @needed.call : @needed[self]
- end
- end
- end # class UserTask
-
- class FileTask < Task
-
- def initialize(*args)
- super
- @ts = T0
- end
-
- def file_target?
- true
- end
-
- def invoke(opt = INVOKE_OPT)
- return circular_dep if @run
- @run = true
- begin
- return if done?
- goto_task_home
- if File.exist? @name
- @ts = File.mtime @name
- internal_invoke opt, false
- else
- @ts = T0
- internal_invoke opt, true
- end
- ensure
- @run = false
- end
- end
-
- def timestamp(opt = INVOKE_OPT)
- File.exist?(@name) ? File.mtime(@name) : T0
- end
-
- def handle_node(dep, opt)
- return true if dep.file_target? && dep.invoke(opt)
- if File.exist? dep.name
- File.mtime(dep.name) > @ts
- elsif !dep.file_target?
- @rac.err_msg @rac.pos_text(rantfile.path, line_number),
- "in prerequisites: no such file: `#{dep.full_name}'"
- self.fail
- end
- end
-
- def handle_timestamped(dep, opt)
- return true if dep.invoke opt
- dep.timestamp(opt) > @ts
- end
-
- def handle_non_node(dep, opt)
- goto_task_home # !!??
- unless File.exist? dep
- @rac.err_msg @rac.pos_text(rantfile.path, line_number),
- "in prerequisites: no such file or task: `#{dep}'"
- self.fail
- end
- [dep, File.mtime(dep) > @ts]
- end
-
- def each_target
- goto_task_home
- yield name
- end
- end # class FileTask
-
- module AutoInvokeDirNode
- private
- def run
- goto_task_home
- return if @rac.running_task(self)
- dir = File.dirname(name)
- @rac.build dir unless dir == "." || dir == "/"
- return unless @block
- @block.arity == 0 ? @block.call : @block[self]
- end
- end
-
- class AutoSubFileTask < FileTask
- include AutoInvokeDirNode
- end
-
- class DirTask < Task
-
- def initialize(*args)
- super
- @ts = T0
- @isdir = nil
- end
-
- def invoke(opt = INVOKE_OPT)
- return circular_dep if @run
- @run = true
- begin
- return if done?
- goto_task_home
- @isdir = test(?d, @name)
- if @isdir
- @ts = @block ? test(?M, @name) : Time.now
- internal_invoke opt, false
- else
- @ts = T0
- internal_invoke opt, true
- end
- ensure
- @run = false
- end
- end
-
- def file_target?
- true
- end
-
- def handle_node(dep, opt)
- return true if dep.file_target? && dep.invoke(opt)
- if File.exist? dep.name
- File.mtime(dep.name) > @ts
- elsif !dep.file_target?
- @rac.err_msg @rac.pos_text(rantfile.path, line_number),
- "in prerequisites: no such file: `#{dep.full_name}'"
- self.fail
- end
- end
-
- def handle_timestamped(dep, opt)
- return @block if dep.invoke opt
- @block && dep.timestamp(opt) > @ts
- end
-
- def handle_non_node(dep, opt)
- goto_task_home
- unless File.exist? dep
- @rac.err_msg @rac.pos_text(rantfile.path, line_number),
- "in prerequisites: no such file or task: `#{dep}'"
- self.fail
- end
- [dep, @block && File.mtime(dep) > @ts]
- end
-
- def run
- return if @rac.running_task(self)
- @rac.sys.mkdir @name unless @isdir
- if @block
- @block.arity == 0 ? @block.call : @block[self]
- goto_task_home
- @rac.sys.touch @name
- end
- end
-
- def each_target
- goto_task_home
- yield name
- end
- end # class DirTask
-
- class SourceNode
- include Node
- def initialize(rac, name, prerequisites = [])
- super()
- @rac = rac
- @name = name or raise ArgumentError, "name not given"
- @pre = prerequisites
- @run = false
- @ts = nil
- end
- def prerequisites
- @pre
- end
- def timestamp(opt = INVOKE_OPT)
- return @ts if @ts
- goto_task_home
- if File.exist?(@name)
- @ts = File.mtime @name
- else
- rac.abort_at(ch, "SourceNode: no such file -- #@name")
- end
- sd = project_subdir
- @pre.each { |f|
- nodes = rac.resolve f, sd
- if nodes.empty?
- if File.exist? f
- mtime = File.mtime f
- @ts = mtime if mtime > @ts
- else
- rac.abort_at(ch,
- "SourceNode: no such file -- #{f}")
- end
- else
- nodes.each { |node|
- node.invoke(opt)
- if node.respond_to? :timestamp
- node_ts = node.timestamp(opt)
- goto_task_home
- @ts = node_ts if node_ts > @ts
- else
- rac.abort_at(ch,
- "SourceNode can't depend on #{node.name}")
- end
- }
- end
- }
- @ts
- end
- def invoke(opt = INVOKE_OPT)
- false
- end
- def related_sources
- @pre
- end
- end # class SourceNode
-
- module Generators
- class Task
- def self.rant_gen(rac, ch, args, &block)
- unless args.size == 1
- rac.abort("Task takes only one argument " +
- "which has to be like one given to the " +
- "`task' function")
- end
- rac.prepare_task(args.first, nil, ch) { |name,pre,blk|
- rac.node_factory.new_custom(rac, name, pre, block)
- }
- end
- end
- class Directory
- def self.rant_gen(rac, ch, args, &block)
- case args.size
- when 1
- name, pre = rac.normalize_task_arg(args.first, ch)
- self.task(rac, ch, name, pre, &block)
- when 2
- basedir = args.shift
- if basedir.respond_to? :to_str
- basedir = basedir.to_str
- else
- rac.abort_at(ch,
- "Directory: basedir argument has to be a string.")
- end
- name, pre = rac.normalize_task_arg(args.first, ch)
- self.task(rac, ch, name, pre, basedir, &block)
- else
- rac.abort_at(ch, "Directory takes one argument, " +
- "which should be like one given to the `task' command.")
- end
- end
-
- def self.task(rac, ch, name, prerequisites=[], basedir=nil, &block)
- dirs = ::Rant::Sys.split_all(name)
- if dirs.empty?
- rac.abort_at(ch,
- "Not a valid directory name: `#{name}'")
- end
- path = basedir
- last_task = nil
- task_block = nil
- desc_for_last = rac.pop_desc
- dirs.each { |dir|
- pre = [path]
- pre.compact!
- if dir.equal?(dirs.last)
- rac.cx.desc desc_for_last
-
- dp = prerequisites.dup
- pre.each { |elem| dp << elem }
- pre = dp
-
- task_block = block
- end
- path = path.nil? ? dir : File.join(path, dir)
- last_task = rac.prepare_task({:__caller__ => ch,
- path => pre}, task_block) { |name,pre,blk|
- rac.node_factory.new_dir(rac, name, pre, blk)
- }
- }
- last_task
- end
- end # class Directory
- class SourceNode
- def self.rant_gen(rac, ch, args)
- unless args.size == 1
- rac.abort_at(ch, "SourceNode takes one argument.")
- end
- if block_given?
- rac.abort_at(ch, "SourceNode doesn't take a block.")
- end
- rac.prepare_task(args.first, nil, ch) { |name, pre, blk|
- rac.node_factory.new_source(rac, name, pre, blk)
- }
- end
- end
- class Rule
- def self.rant_gen(rac, ch, args, &block)
- unless args.size == 1
- rac.abort_at(ch, "Rule takes only one argument.")
- end
- rac.abort_at(ch, "Rule: block required.") unless block
- arg = args.first
- target = nil
- src_arg = nil
- if Symbol === arg
- target = ".#{arg}"
- elsif arg.respond_to? :to_str
- target = arg.to_str
- elsif Regexp === arg
- target = arg
- elsif Hash === arg && arg.size == 1
- arg.each_pair { |target, src_arg| }
- src_arg = src_arg.to_str if src_arg.respond_to? :to_str
- target = target.to_str if target.respond_to? :to_str
- src_arg = ".#{src_arg}" if Symbol === src_arg
- target = ".#{target}" if Symbol === target
- else
- rac.abort_at(ch, "Rule argument " +
- "has to be a hash with one key-value pair.")
- end
- esc_target = nil
- target_rx = case target
- when String
- esc_target = Regexp.escape(target)
- /#{esc_target}$/
- when Regexp
- target
- else
- rac.abort_at(ch, "rule target has " +
- "to be a string or regular expression")
- end
- src_proc = case src_arg
- when String, Array
- unless String === target
- rac.abort(ch, "rule target has to be " +
- "a string if source is a string")
- end
- if src_arg.kind_of? String
- lambda { |name|
- name.sub(/#{esc_target}$/, src_arg)
- }
- else
- lambda { |name|
- src_arg.collect { |s_src|
- s_src = ".#{s_src}" if Symbol === s_src
- name.sub(/#{esc_target}$/, s_src)
- }
- }
- end
- when Proc; src_arg
- when nil; lambda { |name| [] }
- else
- rac.abort_at(ch, "rule source has to be a " +
- "String, Array or Proc")
- end
- rac.resolve_hooks <<
- (block.arity == 2 ? Hook : FileHook).new(
- rac, ch, target_rx, src_proc, block)
- nil
- end
- class Hook
- attr_accessor :target_rx
- def initialize(rant, ch, target_rx, src_proc, block)
- @rant = rant
- @ch = ch
- @target_rx = target_rx
- @src_proc = src_proc
- @block = block
- end
- def call(target, rel_project_dir)
- if @target_rx =~ target
- have_src = true
- src = @src_proc[target]
- if src.respond_to? :to_ary
- have_src = src.to_ary.all? { |s|
- have_src?(rel_project_dir, s)
- }
- else
- have_src = have_src?(rel_project_dir, src)
- end
- if have_src
- create_nodes(rel_project_dir, target, src)
- end
- end
- end
- alias [] call
- private
- def have_src?(rel_project_dir, name)
- return true unless
- @rant.rec_save_resolve(name, self, rel_project_dir).empty?
- test(?e, @rant.abs_path(rel_project_dir, name))
- end
- def create_nodes(rel_project_dir, target, deps)
- @rant.goto_project_dir rel_project_dir
- case nodes = @block[target, deps]
- when Array; nodes
- when Node; [nodes]
- else
- @rant.abort_at(@ch, "Block has to " +
- "return Node or array of Nodes.")
- end
- end
- end
- class FileHook < Hook
- private
- def have_src?(rel_project_dir, name)
- test(?e, @rant.abs_path(rel_project_dir, name)) or
- @rant.rec_save_resolve(name, self, rel_project_dir
- ).any? { |t| t.file_target? }
- end
- def create_nodes(rel_project_dir, target, deps)
- @rant.goto_project_dir rel_project_dir
- t = @rant.file(:__caller__ => @ch,
- target => deps, &@block)
- [t]
- end
- end
- end # class Rule
- class Action
- def self.rant_gen(rac, ch, args, &block)
- case args.size
- when 0
- unless (rac[:tasks] || rac[:stop_after_load])
- yield
- end
- when 1
- rx = args.first
- unless rx.kind_of? Regexp
- rac.abort_at(ch, "Action: argument has " +
- "to be a regular expression.")
- end
- rac.resolve_hooks << self.new(rac, block, rx)
- nil
- else
- rac.abort_at(ch, "Action: too many arguments.")
- end
- end
- def initialize(rant, block, rx)
- @rant = rant
- @subdir = @rant.current_subdir
- @block = block
- @rx = rx
- end
- def call(target, rel_project_dir)
- if target =~ @rx
- @rant.resolve_hooks.delete(self)
- @rant.goto_project_dir @subdir
- @block.call
- @rant.resolve(target, rel_project_dir)
- end
- end
- alias [] call
- end
- end # module Generators
-end # module Rant
-
-Rant::MAIN_OBJECT = self
-
-class String
- alias sub_ext _rant_sub_ext
- def to_rant_target
- self
- end
-end
-
-module Rant::Lib
- def parse_caller_elem(elem)
- return { :file => "", :ln => 0 } unless elem
- if elem =~ /^(.+):(\d+)(?::|$)/
- { :file => $1, :ln => $2.to_i }
- else
- $stderr.puts "parse_caller_elem: #{elem.inspect}"
- { :file => elem, :ln => 0 }
- end
-
- 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
- RANT_PREFIX
- end
- 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
- 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
-
-module RantContext
- include Rant::Generators
-
- Env = Rant::Env
- FileList = Rant::FileList
-
- def task(targ, &block)
- rant.task(targ, &block)
- end
-
- def file(targ, &block)
- rant.file(targ, &block)
- end
-
- def enhance(targ, &block)
- rant.enhance(targ, &block)
- end
-
- def desc(*args)
- rant.desc(*args)
- end
-
- def gen(*args, &block)
- rant.gen(*args, &block)
- end
-
- def import(*args, &block)
- rant.import(*args, &block)
- end
-
- def plugin(*args, &block)
- rant.plugin(*args, &block)
- end
-
- def subdirs(*args)
- rant.subdirs(*args)
- end
-
- def source(opt, rantfile = nil)
- rant.source(opt, rantfile)
- end
-
- def sys(*args, &block)
- rant.sys(*args, &block)
- end
-
- def var(*args, &block)
- rant.var(*args, &block)
- end
-
- def make(*args, &block)
- rant.make(*args, &block)
- end
-
-end # module RantContext
-
-class RantAppContext
- include RantContext
-
- def initialize(app)
- @__rant__ = app
- end
-
- def rant
- @__rant__
- end
-
- def method_missing(sym, *args)
- Rant::MAIN_OBJECT.send(sym, *args)
- rescue NoMethodError
- raise NameError, "NameError: undefined local " +
- "variable or method `#{sym}' for main:Object", caller
- end
-end
-
-module Rant
-
- @__rant__ = nil
- class << self
-
- def run(first_arg=nil, *other_args)
- other_args = other_args.flatten
- args = first_arg.nil? ? ARGV.dup : ([first_arg] + other_args)
- if rant && !rant.run?
- rant.run(args.flatten)
- else
- @__rant__ = Rant::RantApp.new
- rant.run(args)
- end
- end
-
- def rant
- @__rant__
- end
- end
-
-end # module Rant
-
-class Rant::RantApp
- include Rant::Console
-
- class AutoLoadNodeFactory
- def initialize(rant)
- @rant = rant
- end
- def method_missing(sym, *args, &block)
- @rant.import "nodes/default"
- @rant.node_factory.send(sym, *args, &block)
- end
- end
-
-
-
- OPTIONS = [
- [ "--help", "-h", GetoptLong::NO_ARGUMENT,
- "Print this help and exit." ],
- [ "--version", "-V", GetoptLong::NO_ARGUMENT,
- "Print version of Rant and exit." ],
- [ "--verbose", "-v", GetoptLong::NO_ARGUMENT,
- "Print more messages to stderr." ],
- [ "--quiet", "-q", GetoptLong::NO_ARGUMENT,
- "Don't print commands." ],
- [ "--err-commands", GetoptLong::NO_ARGUMENT,
- "Print failed commands and their exit status." ],
- [ "--directory","-C", GetoptLong::REQUIRED_ARGUMENT,
- "Run rant in DIRECTORY." ],
- [ "--cd-parent","-c", GetoptLong::NO_ARGUMENT,
- "Run rant in parent directory with Rantfile." ],
- [ "--look-up", "-u", GetoptLong::NO_ARGUMENT,
- "Look in parent directories for root Rantfile." ],
- [ "--rantfile", "-f", GetoptLong::REQUIRED_ARGUMENT,
- "Process RANTFILE instead of standard rantfiles.\n" +
- "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." ],
-
-
- [ "--import", "-i", GetoptLong::REQUIRED_ARGUMENT, nil ],
- [ "--stop-after-load", GetoptLong::NO_ARGUMENT, nil ],
- [ "--trace-abort", GetoptLong::NO_ARGUMENT, nil ],
- ]
-
- ROOT_DIR_ID = "@"
- ESCAPE_ID = "\\"
-
- attr_reader :args
- attr_reader :rantfiles
- attr_reader :force_targets
- attr_reader :plugins
- attr_reader :context
- alias cx context
- attr_reader :tasks
- attr_reader :imports
- attr_reader :current_subdir
- attr_reader :resolve_hooks
- attr_reader :rootdir
-
- attr_accessor :node_factory
-
- def initialize
- @args = []
- @context = RantAppContext.new(self)
- @sys = ::Rant::SysObject.new(self)
- @rantfiles = []
- @tasks = {}
- @opts = {
- :verbose => 0,
- :quiet => false,
- }
- @rootdir = Dir.pwd # root directory of project
- @arg_rantfiles = [] # rantfiles given in args
- @arg_targets = [] # targets given in args
- @force_targets = [] # targets given with -a option
- @run = false # run method was called at least once
- @done = false # run method was successful
- @plugins = []
- @var = Rant::RantVar::Space.new
- @var.query :ignore, :AutoList, []
- @imports = []
-
- @task_desc = nil
- @last_build_subdir = ""
-
- @current_subdir = ""
- @resolve_hooks = []
-
- @node_factory = AutoLoadNodeFactory.new(self)
- end
-
- def [](opt)
- @opts[opt]
- end
-
- def []=(opt, val)
- @opts[opt] = val
- end
-
- def expand_path(subdir, path)
- case path
- when nil; subdir.dup
- when ""; subdir.dup
- when /^@/; path.sub(/^@/, '')
- else
- path = path.sub(/^\\(?=@)/, '')
- if subdir.empty?
- path
- else
- File.join(subdir, path)
- end
- end
- end
- def resolve_root_ref(path)
- return File.join(@rootdir, path[1..-1]) if path =~ /^@/
- path.sub(/^\\(?=@)/, '')
- end
- def project_to_fs_path(path)
- sub = expand_path(@current_subdir, path)
- sub.empty? ? @rootdir : File.join(@rootdir, sub)
- end
- def abs_path(subdir, fn)
- return fn if Rant::Sys.absolute_path?(fn)
- path = File.join(@rootdir, subdir, fn)
- path.gsub!(%r{/+}, "/")
- path.sub!(%r{/$}, "") if path.length > 1
- path
- end
- def goto(dir)
- goto_project_dir(expand_path(@current_subdir, dir))
- end
- def goto_project_dir(dir='')
- @current_subdir = dir
- abs_path = @current_subdir.empty? ?
- @rootdir : File.join(@rootdir, @current_subdir)
- unless Dir.pwd == abs_path
- Dir.chdir abs_path
- vmsg 1, "in #{abs_path}"
- end
- end
-
- def run?
- @run
- end
-
- def done?
- @done
- end
-
- def run(*args)
- @run = true
- @args.concat(args.flatten)
- orig_pwd = @rootdir = Dir.pwd
- process_args
- Dir.chdir(@rootdir) rescue abort $!.message
- load_rantfiles
-
- raise Rant::RantDoneException if @opts[:stop_after_load]
-
- @plugins.each { |plugin| plugin.rant_start }
- if @opts[:tasks]
- show_descriptions
- raise Rant::RantDoneException
- end
- run_tasks
- raise Rant::RantDoneException
- rescue Rant::RantDoneException
- @done = true
- @plugins.each { |plugin| plugin.rant_done }
- return 0
- rescue Rant::RantAbortException
- $stderr.puts "rant aborted!"
- return 1
- rescue Exception => e
- ch = get_ch_from_backtrace(e.backtrace)
- if ch && !@opts[:trace_abort]
- err_msg(pos_text(ch[:file], ch[:ln]), e.message)
- else
- err_msg e.message, e.backtrace[0..4]
- end
- $stderr.puts "rant aborted!"
- return 1
- ensure
- Dir.chdir @rootdir if test ?d, @rootdir
- hooks = var._get("__at_return__")
- hooks.each { |hook| hook.call } if hooks
- @plugins.each { |plugin| plugin.rant_plugin_stop }
- @plugins.each { |plugin| plugin.rant_quit }
- Dir.chdir orig_pwd
- end
-
-
- def desc(*args)
- if args.empty? || (args.size == 1 && args.first.nil?)
- @task_desc = nil
- else
- @task_desc = args.join("\n")
- end
- end
-
- def task(targ, &block)
- prepare_task(targ, block) { |name,pre,blk|
- @node_factory.new_task(self, name, pre, blk)
- }
- end
-
- def file(targ, &block)
- prepare_task(targ, block) { |name,pre,blk|
- @node_factory.new_file(self, name, pre, blk)
- }
- end
-
- def gen(*args, &block)
- ch = Rant::Lib::parse_caller_elem(caller[1])
- generator = args.shift
- unless generator.respond_to? :rant_gen
- abort_at(ch,
- "gen: First argument has to be a task-generator.")
- end
- generator.rant_gen(self, ch, args, &block)
- end
-
- def import(*args, &block)
- ch = Rant::Lib::parse_caller_elem(caller[1])
- if block
- warn_msg pos_text(ch[:file], ch[:ln]),
- "import: ignoring block"
- end
- args.flatten.each { |arg|
- unless String === arg
- abort_at(ch, "import: only strings allowed as arguments")
- end
- unless @imports.include? arg
- unless Rant::CODE_IMPORTS.include? arg
- begin
- vmsg 2, "import #{arg}"
- require "rant/import/#{arg}"
- rescue LoadError => e
- abort_at(ch, "No such import - #{arg}")
- end
- Rant::CODE_IMPORTS << arg.dup
- end
- init_msg = "init_import_#{arg.gsub(/[^\w]/, '__')}"
- Rant.send init_msg, self if Rant.respond_to? init_msg
- @imports << arg.dup
- end
- }
- end
-
- def plugin(*args, &block)
- clr = caller[1]
- ch = Rant::Lib::parse_caller_elem(clr)
- name = nil
- pre = []
- ln = ch[:ln] || 0
- file = ch[:file]
-
- pl_name = args.shift
- pl_name = pl_name.to_str if pl_name.respond_to? :to_str
- pl_name = pl_name.to_s if pl_name.is_a? Symbol
- unless pl_name.is_a? String
- abort(pos_text(file, ln),
- "Plugin name has to be a string or symbol.")
- end
- lc_pl_name = pl_name.downcase
- import_name = "plugin/#{lc_pl_name}"
- unless Rant::CODE_IMPORTS.include? import_name
- begin
- require "rant/plugin/#{lc_pl_name}"
- Rant::CODE_IMPORTS << import_name
- rescue LoadError
- abort(pos_text(file, ln),
- "no such plugin library -- #{lc_pl_name}")
- end
- end
- pl_class = nil
- begin
- pl_class = ::Rant::Plugin.const_get(pl_name)
- rescue NameError, ArgumentError
- abort(pos_text(file, ln),
- "no such plugin -- #{pl_name}")
- end
-
- plugin = pl_class.rant_plugin_new(self, ch, *args, &block)
- @plugins << plugin
- vmsg 2, "Plugin `#{plugin.rant_plugin_name}' registered."
- plugin.rant_plugin_init
- plugin
- end
-
- def enhance(targ, &block)
- prepare_task(targ, block) { |name,pre,blk|
- t = resolve(name).last
- if t
- unless t.respond_to? :enhance
- abort("Can't enhance task `#{name}'")
- end
- t.enhance(pre, &blk)
- return t
- end
- warn_msg "enhance \"#{name}\": no such task",
- "Generating a new file task with the given name."
- @node_factory.new_file(self, name, pre, blk)
- }
- end
-
- def source(opt, rantfile = nil)
- unless rantfile
- rantfile = opt
- opt = nil
- end
- make_rf = opt != :n && opt != :now
- rf, is_new = rantfile_for_path(rantfile)
- return false unless is_new
- make rantfile if make_rf
- unless File.exist? rf.path
- abort("source: No such file -- #{rantfile}")
- end
-
- load_file rf
- end
-
- def subdirs(*args)
- args.flatten!
- ch = Rant::Lib::parse_caller_elem(caller[1])
- args.each { |arg|
- if arg.respond_to? :to_str
- arg = arg.to_str
- else
- abort_at(ch, "subdirs: arguments must be strings")
- end
- loaded = false
- prev_subdir = @current_subdir
- begin
- goto arg
- if test(?f, Rant::SUB_RANTFILE)
- path = Rant::SUB_RANTFILE
- else
- path = rantfile_in_dir
- end
- if path
- if defined? @initial_subdir and
- @initial_subdir == @current_subdir
- rf, is_new = rantfile_for_path(path, false)
- @rantfiles.unshift rf if is_new
- else
- rf, is_new = rantfile_for_path(path)
- end
- load_file rf if is_new
- elsif !@opts[:no_warn_subdir]
- warn_msg(pos_text(ch[:file], ch[:ln]),
- "subdirs: No Rantfile in subdir `#{arg}'.")
- end
- ensure
- goto_project_dir prev_subdir
- end
- }
- rescue SystemCallError => e
- abort_at(ch, "subdirs: " + e.message)
- end
-
- def sys(*args, &block)
- args.empty? ? @sys : @sys.sh(*args, &block)
- end
-
- def var(*args, &block)
- args.empty? ? @var : @var.query(*args, &block)
- end
-
- def pop_desc
- td = @task_desc
- @task_desc = nil
- td
- end
-
- def abort(*msg)
- err_msg(msg) unless msg.empty?
- $stderr.puts caller if @opts[:trace_abort]
- raise Rant::RantAbortException
- end
-
- def abort_at(ch, *msg)
- err_msg(pos_text(ch[:file], ch[:ln]), msg)
- $stderr.puts caller if @opts[:trace_abort]
- raise Rant::RantAbortException
- end
-
- def show_help
- puts "rant [-f Rantfile] [Options] [targets]"
- puts
- puts "Options are:"
- print option_listing(OPTIONS)
- end
-
- def show_descriptions
- tlist = select_tasks { |t| t.description }
- def_target = target_list.first
- if tlist.empty?
- puts "rant # => " + list_task_names(
- resolve(def_target)).join(', ')
- msg "No described tasks."
- return
- end
- prefix = "rant "
- infix = " # "
- name_length = (tlist.map{ |t| t.to_s.length } << 7).max
- cmd_length = prefix.length + name_length
- unless tlist.first.to_s == def_target
- defaults = list_task_names(
- resolve(def_target)).join(', ')
- puts "#{prefix}#{' ' * name_length}#{infix}=> #{defaults}"
- end
- tlist.each { |t|
- print(prefix + t.to_s.ljust(name_length) + infix)
- dt = t.description.sub(/\s+$/, "")
- puts dt.gsub(/\n/, "\n" + ' ' * cmd_length + infix + " ")
- }
- true
- end
-
- def list_task_names(*tasks)
- rsl = []
- tasks.flatten.each { |t|
- if t.respond_to?(:has_actions?) && t.has_actions?
- rsl << t
- elsif t.respond_to? :prerequisites
- if t.prerequisites.empty?
- rsl << t
- else
- t.prerequisites.each { |pre|
- rsl.concat(list_task_names(
- resolve(pre, t.project_subdir)))
- }
- end
- else
- rsl << t
- end
- }
- rsl
- end
- private :list_task_names
-
- def verbose
- @opts[:verbose]
- end
-
- def quiet?
- @opts[:quiet]
- end
-
- def pos_text(file, ln)
- t = "in file `#{file}'"
- t << ", line #{ln}" if ln && ln > 0
- t << ": "
- end
-
- def cmd_msg(cmd)
- puts cmd unless quiet?
- end
-
- def cmd_print(text)
- print text unless quiet?
- $stdout.flush
- end
-
- def cmd_targets
- @force_targets + @arg_targets
- end
-
- def running_task(task)
- if @current_subdir != @last_build_subdir
- cmd_msg "(in #{@current_subdir.empty? ?
- @rootdir : @current_subdir})"
- @last_build_subdir = @current_subdir
- end
- if @opts[:dry_run]
- task.dry_run
- true
- end
- end
-
- private
- def have_any_task?
- !@tasks.empty?
- end
-
- def target_list
- if !have_any_task? && @resolve_hooks.empty?
- abort("No tasks defined for this rant application!")
- end
-
- target_list = @force_targets + @arg_targets
- if target_list.empty?
- def_tasks = resolve "default"
- unless def_tasks.empty?
- target_list << "default"
- else
- @rantfiles.each { |f|
- first = f.tasks.first
- if first
- target_list << first.reference_name
- break
- end
- }
- end
- end
- target_list
- end
-
- def run_tasks
- target_list.each { |target|
- if build(target) == 0
- abort("Don't know how to make `#{target}'.")
- end
- }
- end
-
- def make(target, *args, &block)
- ch = nil
- if target.respond_to? :to_hash
- targ = target.to_hash
- ch = Rant::Lib.parse_caller_elem(caller[1])
- abort_at(ch, "make: too many arguments") unless args.empty?
- tn = nil
- prepare_task(targ, block, ch) { |name,pre,blk|
- tn = name
- @node_factory.new_file(self, name, pre, blk)
- }
- build(tn)
- elsif target.respond_to? :to_rant_target
- rt = target.to_rant_target
- opt = args.shift
- unless args.empty?
- ch ||= Rant::Lib.parse_caller_elem(caller[1])
- abort_at(ch, "make: too many arguments")
- end
- if block
- ch ||= Rant::Lib.parse_caller_elem(caller[1])
- prepare_task(rt, block, ch) { |name,pre,blk|
- @node_factory.new_file(self, name, pre, blk)
- }
- build(rt)
- else
- build(rt, opt||{})
- end
- elsif target.respond_to? :rant_gen
- ch = Rant::Lib.parse_caller_elem(caller[1])
- rv = target.rant_gen(self, ch, args, &block)
- unless rv.respond_to? :to_rant_target
- abort_at(ch, "make: invalid generator return value")
- end
- build(rv.to_rant_target)
- rv
- else
- ch = Rant::Lib.parse_caller_elem(caller[1])
- abort_at(ch,
- "make: generator or target as first argument required.")
- end
- end
- public :make
-
- def build(target, opt = {})
- opt[:force] = true if @force_targets.delete(target)
- opt[:dry_run] = @opts[:dry_run]
- matching_tasks = 0
- old_subdir = @current_subdir
- old_pwd = Dir.pwd
- resolve(target).each { |t|
- unless opt[:type] == :file && !t.file_target?
- matching_tasks += 1
- begin
- t.invoke(opt)
- rescue Rant::TaskFail => e
- err_task_fail(e)
- abort
- end
- end
- }
- @current_subdir = old_subdir
- Dir.chdir old_pwd
- matching_tasks
- end
- public :build
-
- def resolve(task_name, rel_project_dir = @current_subdir)
- s = @tasks[expand_path(rel_project_dir, task_name)]
- case s
- when nil
- @resolve_hooks.each { |s|
- s = s[task_name, rel_project_dir]
- return s if s
- }
- []
- when Rant::Node; [s]
- else # assuming list of tasks
- s
- end
- 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
-
- def at_resolve(&block)
- @resolve_hooks << block if block
- end
- public :at_resolve
-
- def at_return(&block)
- hooks = var._get("__at_return__")
- if hooks
- hooks << block
- else
- var._set("__at_return__", [block])
- end
- end
- public :at_return
-
- def select_tasks
- selection = []
- @rantfiles.each { |rf|
- rf.tasks.each { |t|
- selection << t if yield t
- }
- }
- selection
- end
- public :select_tasks
-
- def load_rantfiles
- unless @arg_rantfiles.empty?
- @arg_rantfiles.each { |fn|
- if test(?f, fn)
- rf, is_new = rantfile_for_path(fn)
- load_file rf if is_new
- else
- abort "No such file -- #{fn}"
- end
- }
- return
- end
- return if have_any_task?
- fn = rantfile_in_dir
- if @opts[:cd_parent]
- old_root = @rootdir
- until fn or @rootdir == "/"
- @rootdir = File.dirname(@rootdir)
- fn = rantfile_in_dir(@rootdir)
- end
- if @rootdir != old_root and fn
- Dir.chdir @rootdir
- cmd_msg "(in #@rootdir)"
- end
- end
- if fn
- rf, is_new = rantfile_for_path(fn)
- load_file rf if is_new
- return
- end
- have_sub_rantfile = test(?f, Rant::SUB_RANTFILE)
- if have_sub_rantfile || @opts[:look_up]
- cur_dir = Dir.pwd
- until cur_dir == "/"
- cur_dir = File.dirname(cur_dir)
- Dir.chdir cur_dir
- fn = rantfile_in_dir
- if fn
- @initial_subdir = @rootdir.sub(
- /^#{Regexp.escape cur_dir}\//, '')
- @rootdir = cur_dir
- cmd_msg "(root is #@rootdir, in #@initial_subdir)"
- @last_build_subdir = @initial_subdir
- rf, is_new = rantfile_for_path(fn)
- load_file rf if is_new
- goto_project_dir @initial_subdir
- if have_sub_rantfile
- rf, is_new = rantfile_for_path(
- Rant::SUB_RANTFILE, false)
- if is_new
- @rantfiles.unshift rf
- load_file rf
- end
- end
- break
- end
- end
- end
- if @rantfiles.empty?
- abort("No Rantfile found, looking for:",
- Rant::RANTFILES.join(", "))
- end
- end
-
- def load_file(rantfile)
- vmsg 1, "source #{rantfile}"
- @context.instance_eval(File.read(rantfile), rantfile)
- end
- private :load_file
-
- def rantfile_in_dir(dir=nil)
- ::Rant::RANTFILES.each { |rfn|
- path = dir ? File.join(dir, rfn) : rfn
- return path if test ?f, path
- }
- nil
- end
-
- def process_args
- old_argv = ARGV.dup
- ARGV.replace(@args.dup)
- cmd_opts = GetoptLong.new(*OPTIONS.collect { |lst| lst[0..-2] })
- cmd_opts.quiet = true
- cmd_opts.each { |opt, value|
- case opt
- when "--verbose"; @opts[:verbose] += 1
- when "--version"
- puts "rant #{Rant::VERSION}"
- raise Rant::RantDoneException
- when "--help"
- show_help
- raise Rant::RantDoneException
- when "--directory"
- @rootdir = File.expand_path(value)
- when "--rantfile"
- @arg_rantfiles << value
- when "--force-run"
- @force_targets << value
- when "--import"
- import value
- else
- @opts[opt.sub(/^--/, '').tr('-', "_").to_sym] = true
- end
- }
- rescue GetoptLong::Error => e
- abort(e.message)
- ensure
- rem_args = ARGV.dup
- ARGV.replace(old_argv)
- rem_args.each { |ra|
- if ra =~ /(^[^=]+)=([^=]+)$/
- vmsg 2, "var: #$1=#$2"
- @var[$1] = $2
- else
- @arg_targets << ra
- end
- }
- end
-
- def prepare_task(targ, block, clr = caller[2])
-
- if targ.is_a? Hash
- targ.reject! { |k, v| clr = v if k == :__caller__ }
- end
- ch = Hash === clr ? clr : Rant::Lib::parse_caller_elem(clr)
-
- name, pre = normalize_task_arg(targ, ch)
-
- file, is_new = rantfile_for_path(ch[:file])
- nt = yield(name, pre, block)
- nt.rantfile = file
- nt.project_subdir = @current_subdir
- nt.line_number = ch[:ln]
- nt.description = @task_desc
- @task_desc = nil
- file.tasks << nt
- hash_task nt
- nt
- end
- public :prepare_task
-
- def hash_task(task)
- n = task.full_name
- et = @tasks[n]
- case et
- when nil
- @tasks[n] = task
- when Rant::Node
- mt = [et, task]
- @tasks[n] = mt
- else # assuming list of tasks
- et << task
- end
- end
-
- def normalize_task_arg(targ, ch)
- name = nil
- pre = []
-
- if targ.is_a? Hash
- if targ.empty?
- abort_at(ch, "Empty hash as task argument, " +
- "task name required.")
- end
- if targ.size > 1
- abort_at(ch, "Too many hash elements, " +
- "should only be one.")
- end
- targ.each_pair { |k,v|
- name = normalize_task_name(k, ch)
- pre = v
- }
- unless ::Rant::FileList === pre
- if pre.respond_to? :to_ary
- pre = pre.to_ary.dup
- pre.map! { |elem|
- normalize_task_name(elem, ch)
- }
- else
- pre = [normalize_task_name(pre, ch)]
- end
- end
- else
- name = normalize_task_name(targ, ch)
- end
-
- [name, pre]
- end
- public :normalize_task_arg
-
- def normalize_task_name(arg, ch)
- return arg if arg.is_a? String
- if Symbol === arg
- arg.to_s
- elsif arg.respond_to? :to_str
- arg.to_str
- else
- abort_at(ch, "Task name has to be a string or symbol.")
- end
- end
-
- def rantfile_for_path(path, register=true)
- abs_path = File.expand_path(path)
- file = @rantfiles.find { |rf| rf.path == abs_path }
- if file
- [file, false]
- else
- file = Rant::Rantfile.new abs_path
- file.project_subdir = @current_subdir
- @rantfiles << file if register
- [file, true]
- end
- end
-
- def get_ch_from_backtrace(backtrace)
- backtrace.each { |clr|
- ch = ::Rant::Lib.parse_caller_elem(clr)
- if ::Rant::Env.on_windows?
- return ch if @rantfiles.any? { |rf|
- rf.path.tr("\\", "/").sub(/^\w\:/, '') ==
- ch[:file].tr("\\", "/").sub(/^\w\:/, '')
- }
- else
- return ch if @rantfiles.any? { |rf|
- rf.path == ch[:file]
- }
- end
- }
- nil
- end
-
- def err_task_fail(e)
- msg = []
- t_msg = ["Task `#{e.tname}' fail."]
- orig = e
- loop { orig = orig.orig; break unless Rant::TaskFail === orig }
- if orig && orig != e && !(Rant::RantAbortException === orig)
- ch = get_ch_from_backtrace(orig.backtrace)
- msg << pos_text(ch[:file], ch[:ln]) if ch
- unless Rant::CommandError === orig && !@opts[:err_commands]
- msg << orig.message
- msg << orig.backtrace[0..4] unless ch
- end
- end
- if e.msg && !e.msg.empty?
- ch = get_ch_from_backtrace(e.backtrace)
- t_msg.unshift(e.msg)
- t_msg.unshift(pos_text(ch[:file], ch[:ln])) if ch
- end
- err_msg msg unless msg.empty?
- err_msg t_msg
- end
-end # class Rant::RantApp
-
-$".concat(['rant/rantlib.rb', 'rant/init.rb', 'rant/rantvar.rb', 'rant/rantsys.rb', 'rant/import/filelist/core.rb', 'rant/node.rb', 'rant/import/nodes/default.rb', 'rant/coregen.rb'])
-Rant::CODE_IMPORTS.concat %w(nodes/default
- )
-
-# Catch a `require "rant"', sad...
-alias require_backup_by_rant require
-def require libf
- if libf == "rant"
- # TODO: needs rework! look at lib/rant.rb
- self.class.instance_eval { include Rant }
- else
- begin
- require_backup_by_rant libf
- rescue
- raise $!, caller
- end
- end
-end
-
-exit Rant.run
--
cgit v1.2.3