#!/usr/bin/env ruby # sisu-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