rant 0.3.0

data/lib/rant/plugin/csharp.rb

@@ -0,0 +1,275 @@
+
+# C# plugin for Rant.
+
+require 'rant/plugin_methods'
+require 'rant/cs_compiler'
+
+module Rant
+
+    class Generators::Assembly < CsCompiler
+	class << self
+
+	    def rant_generate(app, clr, args, &block)
+		assembly = self.new(&block)
+		if args.size == 1
+		    targ = args.first
+		    # embed caller information for correct resolving
+		    # of source Rantfile
+		    if targ.is_a? Hash
+			targ[:__caller__] = clr
+		    else
+			targ = { :__caller__ => clr, targ => [] }
+		    end
+		    app.prepare_task(targ, nil) { |name,pre,blk|
+			assembly.out = name
+			t = AssemblyTask.new(app, assembly, &block)
+			# TODO: optimize
+			pre.each { |e| t << e }
+			t
+		    }
+		else
+		    cinf = ::Rant::Lib.parse_caller_elem(clr)
+		    app.abort(app.pos_text(cinf[:file], cinf[:ln]),
+			"Assembly takes one argument, " +
+			"which should be like one given to the `task' command.")
+		end
+	    end
+
+	    def csc
+		@csc
+	    end
+	    def csc= new_csc
+		case new_csc
+		when CsCompiler
+		    @csc = new_csc
+		when String
+		    @csc = CsCompiler.new(
+			CsCompiler.cs_compiler_name(new_csc))
+		    @csc.csc_bin = new_csc
+		when nil
+		    @csc = nil
+		else
+		    self.csc = new_csc.to_s
+		end
+		@csc
+	    end
+	end
+	@csc = nil
+
+	# Maybe:
+	# ["object"]
+	#	Compile to object code. Not *that* usual for .NET.
+	# ["dll"]
+	#	Create a shared library (also called DLL).
+	# ["exe"]
+	#	Create an executable.
+	attr_accessor :target
+
+	def initialize(comp = nil, &init_block)
+	    super()
+	    @target = nil
+	    @init_block = init_block
+	    take_common_attrs comp if comp
+	end
+
+	# Synonym for +out+.
+	def name
+	    out
+	end
+
+	# Synonym for +out=+.
+	def name=(new_name)
+	    out = new_name
+	end
+
+	# Take common attributes like +optimize+, +csc+ and similar
+	# from the compiler object +comp+.
+	def take_common_attrs comp
+	    @csc_name = comp.csc_name
+	    @long_name = comp.long_name
+	    @csc = comp.csc
+	    @debug = comp.debug
+	    comp.defines.each { |e|
+		@defines << e unless @defines.include? e
+	    }
+	    comp.lib_link_pathes.each { |e|
+		@lib_link_pathes << e unless @lib_link_pathes.include?  e
+	    }
+	    @optimize = comp.optimize
+	    @warnings = comp.warnings
+	    # TODO: we currently take unconditionally all misc- and
+	    # compiler specific args
+	    comp.misc_args.each { |e|
+		@misc_args << e unless @misc_args.include? e
+	    }
+	    comp.specific_args.each_pair { |k,v|
+		# k is a compiler name, v is a list of arguments
+		# specific to this compiler type.
+		cst = @specific_args[k]
+		unless cst
+		    @specific_args[k] = v
+		    next
+		end
+		v.each { |e|
+		    cst << e unless cst.include? e
+		}
+	    }
+	end
+
+	# Call the initialization block and intialize compiler
+	# interface.
+	def init
+	    # setup compiler interface
+	    comp = Plugin::Csharp.csc_for_assembly(self) || self.class.csc
+	    take_common_attrs comp if comp
+
+	    # call initialization block
+	    @init_block[self] if @init_block
+
+	    # set target type
+	    unless @target
+		@target = case @out
+		when /\.exe$/i: "exe"
+		when /\.dll$/i: "dll"
+		when /\.obj$/i: "object"
+		else "exe"
+		end
+	    end
+	    # TODO: verify some attributes like @target
+	end
+
+	def compile
+	    ::Rant::Sys.sh(self.send("cmd_" + @target))
+	end
+
+    end	# class Generators::Assembly
+
+    class AssemblyTask < FileTask
+	def initialize(app, assembly)
+	    @assembly = assembly
+	    super(app, @assembly.out) { |t|
+		app.context.instance_eval {
+		    sys.sh assembly.send("cmd_" + assembly.target)
+		}
+	    }
+	end
+	def resolve_prerequisites
+	    @assembly.init
+	    @pre.concat(@assembly.sources)
+	    @pre.concat(@assembly.resources) if @assembly.resources
+	    super
+	end
+	### experimental ###
+	def invoke(force = false)
+	    @assembly.init
+	    @pre.concat(@assembly.sources)
+	    @pre.concat(@assembly.resources) if @assembly.resources
+	    super
+	end
+	####################
+    end
+end	# module Rant
+
+module Rant::Plugin
+
+    # This plugin class is currently designed to be instantiated only
+    # once with +rant_plugin_new+.
+    class Csharp
+	include ::Rant::PluginMethods
+
+	@plugin_object = nil
+	class << self
+
+	    def rant_plugin_new(app, cinf, *args, &block)
+		if args.size > 1
+		    app.abort(app.pos_text(cinf[:file], cinf[:ln]),
+			"Csharp plugin takes only one argument.")
+		end
+		self.new(app, args.first, &block)
+	    end
+
+	    attr_accessor :plugin_object
+
+	    def csc_for_assembly(task)
+		if @plugin_object
+		    @plugin_object.csc_for_assembly(task)
+		else
+		    nil
+		end
+	    end
+	end
+
+	# Shortcut for rant_plugin_name.
+	attr_reader :name
+	# A "configure" plugin.
+	attr_accessor :config
+	# A compiler interface with settings resulting from config.
+	attr_reader :config_csc
+
+	def initialize(app, name = nil)
+	    @name = name || rant_plugin_type
+	    @app = app or raise ArgumentError, "no application given"
+	    @config_csc = nil
+	    @config = nil
+
+	    self.class.plugin_object = self
+
+	    yield self if block_given?
+
+	    define_config_checks
+	end
+
+	def csc_for_assembly(assembly)
+	    @config_csc ||= csc_from_config
+	    @config_csc.nil? ? nil : @config_csc.dup
+	end
+
+	def define_config_checks
+	    return unless @config
+	    @config.check "csc" do |c|
+		c.default "cscc"
+		c.guess {
+		    Rant::CsCompiler.look_for_cs_compiler
+		}
+		c.interact {
+		    c.prompt "Command to invoke your C# Compiler: "
+		}
+		c.react {
+		    c.msg "Using `#{c.value}' as C# compiler."
+		}
+	    end
+	    @config.check "csc-optimize" do |c|
+		c.default true
+		c.interact {
+		    c.ask_yes_no "Optimize C# compilation?"
+		}
+	    end
+	    @config.check "csc-debug" do |c|
+		c.default false
+		c.interact {
+		    c.ask_yes_no "Compile C# sources for debugging?"
+		}
+	    end
+	end
+
+	def csc_from_config
+	    return nil unless @config
+	    return nil unless @config.configured?
+	    csc_bin = @config["csc"]
+	    csc = Rant::CsCompiler.new
+	    csc.csc = csc_bin
+	    csc.optimize = @config["csc-optimize"]
+	    csc.debug = @config["csc-debug"]
+	    csc
+	end
+
+	###### methods override from PluginMethods ###################
+	def rant_plugin_type
+	    "csharp"
+	end
+	def rant_plugin_name
+	    @name
+	end
+	##############################################################
+    end # class Csharp
+end	# module Rant::Plugin

data/lib/rant/plugin_methods.rb

@@ -0,0 +1,41 @@
+
+require 'rant/rantlib'
+
+# This module defines all instance methods required for an Rant
+# plugin. Additionally, each plugin class has to define the class
+# method +plugin_create+.
+#
+# Include this module in your plugin class to ensure your plugin won't
+# break when Rant requires new methods.
+module Rant::PluginMethods
+    # The type of your plugin as string.
+    def rant_plugin_type
+	"rant plugin"
+    end
+    # Please override this method. This is used as a name for your
+    # plugin instance.
+    def rant_plugin_name
+	"rant plugin object"
+    end
+    # This is used for verification. Usually you don't want to change
+    # this for your plugin :-)
+    def rant_plugin?
+	true
+    end
+    # Called immediately after registration.
+    def rant_plugin_init
+    end
+    # Called before rant runs the first task.
+    def rant_start
+    end
+    # Called when rant *successfully* processed all required tasks.
+    def rant_done
+    end
+    # You should "shut down" your plugin as response to this method.
+    def rant_plugin_stop
+    end
+    # Called immediately before the rant application return control to
+    # the caller.
+    def rant_quit
+    end
+end # module Rant::PluginMethods

data/lib/rant/rantenv.rb

@@ -0,0 +1,217 @@
+#!/usr/bin/ruby
+
+require 'rbconfig'
+
+module Rant end
+
+class Rant::Path
+    attr_reader :path
+    def initialize path, abs_path = nil
+	@path = path or raise ArgumentError, "path not given"
+	@abs_path = abs_path
+    end
+    def to_s
+	@path.dup
+    end
+    def to_str
+	@path.dup
+    end
+    def exist?
+	File.exist? @path
+    end
+    def file?
+	test ?f, @path
+    end
+    def dir?
+	test ?d, @path
+    end
+    def mtime
+	File.mtime @path
+    end
+    def absolute_path
+	@abs_path ||= File.expand_path(@path)
+    end
+end
+
+# This module provides some platform indenpendant
+# (let's hope) environment information.
+module Rant::Env
+    OS		= ::Config::CONFIG['target']
+    RUBY	= ::Config::CONFIG['ruby_install_name']
+
+    @@zip_bin = false
+    @@tar_bin = false
+
+    def on_windows?
+        OS =~ /mswin/i
+    end
+
+    def have_zip?
+	if @@zip_bin == false
+	    @@zip_bin = find_bin "zip"
+	end
+	!@@zip_bin.nil?
+    end
+
+    def have_tar?
+	if @@tar_bin == false
+	    @@tar_bin = find_bin "tar"
+	end
+	!@@tar_bin.nil?
+    end
+
+    # Get an array with all pathes in the PATH
+    # environment variable.
+    def pathes
+	# Windows doesn't care about case in environment variables,
+	# but the ENV hash does!
+        path = on_windows? ? ENV["Path"] : ENV["PATH"]
+        return [] unless path
+        if on_windows?
+            path.split(";")
+        else
+            path.split(":")
+        end
+    end
+
+    # Searches for bin_name on path and returns
+    # an absolute path if successfull or nil
+    # if an executable called bin_name couldn't be found.
+    def find_bin bin_name
+        if on_windows?
+            bin_name_exe = nil
+	    if bin_name !~ /\.[^\.]{1,3}$/i
+		bin_name_exe = bin_name + ".exe"
+	    end
+	    pathes.each { |dir|
+		file = File.join(dir, bin_name)
+		return file if test(?f, file)
+		if bin_name_exe
+		    file = File.join(dir, bin_name_exe)
+		    return file if test(?f, file)
+		end
+	    }
+	else
+	    pathes.each { |dir|
+		file = File.join(dir, bin_name)
+		return file if test(?x, file)
+	    }
+	end
+        nil
+    end
+
+    # Add quotes to a path and replace File::Separators if necessary.
+    def shell_path path
+	# TODO: check for more characters when deciding wheter to use
+	# quotes.
+	if on_windows?
+	    path = path.tr("/", "\\")
+	    if path.include? ' '
+		'"' + path + '"'
+	    else
+		path
+	    end
+	else
+	    if path.include? ' '
+		"'" + path + "'"
+	    else
+		path
+	    end
+	end
+    end
+
+    extend self
+end    # module Rant::Env
+
+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
+        text = text.join("\n" + ' ' * pre.length)
+        $stderr.puts(pre + text)
+    end
+    def err_msg *text
+        pre = msg_prefix + ERROR_PREFIX
+        text = text.join("\n" + ' ' * pre.length)
+        $stderr.puts(pre + text)
+    end
+    def warn_msg *text
+        pre = msg_prefix + WARN_PREFIX
+        text = text.join("\n" + ' ' * pre.length)
+        $stderr.puts(pre + text)
+    end
+    def ask_yes_no text
+        $stderr.print msg_prefix + text + " [y|n] "
+        case $stdin.readline
+        when /y|yes/i: true
+        when /n|no/i: false
+        else
+            $stderr.puts(' ' * msg_prefix.length +
+                "Please answer with `yes' or `no'")
+            ask_yes_no text
+        end
+    end
+    def prompt text
+        $stderr.print msg_prefix + text
+        input = $stdin.readline
+	input ? input.chomp : input
+    end
+    def option_listing opts
+	rs = ""
+	opts.each { |lopt, *opt_a|
+	    if opt_a.size == 2
+		# no short option
+		mode, desc = opt_a
+	    else
+		sopt, mode, desc = opt_a
+	    end
+	    next unless desc	# "private" option
+	    optstr = ""
+	    arg = nil
+	    if mode == GetoptLong::REQUIRED_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
+
+class Rant::CustomConsole
+    include Rant::Console
+
+    def initialize msg_prefix = RANT_PREFIX
+	@msg_prefix = msg_prefix || ""
+    end
+    def msg_prefix=(str)
+	@msg_prefix = str || ""
+    end
+end