rant 0.3.0

data/lib/rant.rb

@@ -0,0 +1,9 @@
+#!/usr/bin/env ruby
+
+require 'rant/rantlib'
+
+include Rant
+
+if $0 == __FILE__
+    exit Rant.run
+end

data/lib/rant/cs_compiler.rb

@@ -0,0 +1,334 @@
+
+require 'rant/rantenv'
+
+module Rant
+    # An object extending this module acts as an
+    # interface to a C# Compiler.
+    class CsCompiler
+
+	LIB_SYSTEM_XML	= "System.Xml.dll"
+	LIB_SYSTEM_DRAWING	= "System.Drawing.dll"
+	LIB_SYSTEM_FORMS	= "System.Windows.Forms.dll"
+
+	class << self
+	    # Get the short name for the compiler referenced by this path.
+	    def cs_compiler_name(path)
+		case path
+		when /csc(\.exe)?$/i
+		    "csc"
+		when /cscc(\.exe)?$/i
+		    "cscc"
+		when /mcs(\.exe)?$/i
+		    "mcs"
+		else
+		    nil
+		end
+	    end
+
+	    # Search for a C# compiler in PATH and some
+	    # usual locations.
+	    def look_for_cs_compiler
+		csc_bin = nil
+		if Env.on_windows?
+		    csc_bin = "csc" if Env.find_bin "csc"
+		    unless csc_bin
+			csc_bin = look_for_csc
+		    end
+		end
+		csc_bin = "cscc" if !csc_bin && Env.find_bin("cscc") 
+		csc_bin = "mcs" if !csc_bin && Env.find_bin("mcs")
+		csc_bin
+	    end
+
+	    # Searches for csc in some usual directories.
+	    # Ment to be used on windows only!
+	    def look_for_csc
+		# Is there a way to get a list of all available
+		# drives?
+		("C".."Z").each { |drive|
+		    ["WINDOWS", "WINNT"].each { |win_dir|
+			frame_dir = drive + ':\\' + win_dir +
+			'\Microsoft.NET\Framework'
+			next unless test(?d,frame_dir)
+			csc_pathes = []
+			Dir.entries(frame_dir).each { |e|
+			    vdir = File.join(frame_dir, e)
+			    if test(?d, vdir)
+				csc_path = File.join(vdir, "csc.exe")
+				if test(?e,csc_path)
+				    csc_pathes << csc_path
+				end
+			    end
+			}
+			next if csc_pathes.empty?
+			return csc_pathes.sort.last
+		    }
+		}
+		nil
+	    rescue
+		nil
+	    end
+	end
+
+	# Short name for compiler, such as "csc", "cscc" or "mcs".
+	attr_reader :csc_name
+	# Descriptive name for compiler.
+	attr_reader :long_name
+	# Compiler path, or cmd on PATH
+	# Look also at the #csc and #csc= methods. Most times they do
+	# what you need.
+	attr_accessor :csc_bin
+	# Debug flag.
+	attr_accessor :debug
+	# Target filename.
+	attr_accessor :out
+	# Libraries to link angainst (usually dlls).
+	attr_accessor :libs
+	# Preprocessor defines.
+	attr_reader :defines
+	# Other args, could be options.
+	# Initialized to an empty array.
+	attr_accessor :misc_args
+	# Hash with compiler specific arguments.
+	attr_accessor :specific_args
+	# Sourcefiles.
+	attr_accessor :sources
+	# Resources to embedd in assembly.
+	attr_accessor :resources
+	# Library link pathes.
+	attr_reader :lib_link_pathes
+	# Entry point for executable.
+	attr_accessor :entry
+	# Optimize, defaults to true
+	attr_accessor :optimize
+	# Enable compiler warnings, defaults to true
+	attr_accessor :warnings
+
+	def initialize(compiler_name=nil)
+	    self.csc_name = (compiler_name || "cscc")
+	    @long_name = "C# Compiler"
+	    @defines = []
+	    @libs = []
+	    @sources = nil
+	    @misc_args = []
+	    @specific_args = {
+		"cscc"  => [],
+		"csc"   => [],
+		"mcs"   => [],
+	    }
+	    @resources = []
+	    @debug = false
+	    @out = "a.out"
+	    @lib_link_pathes = []
+	    @entry = nil
+	    @optimize = true
+	    @warnings = true
+	    @csc = nil
+	    @csc_bin = nil
+	end
+
+	# Command to invoke compiler.
+	def csc
+	    @csc_bin || @csc_name
+	end
+
+	# Set this to command to invoke your compiler. Contrary to
+	# +cc_bin+, this also tries to determine which interface to
+	# use for this compiler. Finally it sets +cc_bin+.
+	def csc=(cmd)
+	    name = self.class.cs_compiler_name(cmd)
+	    @csc_name = name if name
+	    @csc_bin = cmd
+	end
+
+	def csc_name= new_name
+	    unless ["cscc", "csc", "mcs"].include?(new_name)
+		raise "Unsupported C# compiler `#{new_name}'"
+	    end
+	    @csc_name = new_name
+	    @long_name = case @csc_name
+	    when "cscc":	"DotGNU C# compiler"
+	    when "csc":	"MS Visual.NET C# compiler"
+	    when "mcs":	"Mono C# compiler"
+	    end
+	end
+
+	# Shortcut for +specific_args+.
+	def sargs
+	    @specific_args
+	end
+
+	# Generate compilation command for executable.
+	def cmd_exe
+	    send @csc_name + "_cmd_exe"
+	end
+
+	def cscc_cmd_exe
+	    # This generates the compilation command
+	    # for cscc.
+	    cc_cmd = csc.dup
+	    cc_cmd << " -e#{entry}" if entry
+	    cc_cmd << cc_cmd_args
+	    cc_cmd
+	end
+
+	def csc_cmd_exe
+	    # This generates the compilation command
+	    # for csc.
+	    cc_cmd = csc.dup
+	    # Use target:winexe only if not debugging,
+	    # because this will suppress a background console window.
+	    cc_cmd << " /target:winexe" unless debug
+	    cc_cmd << " /main:#{entry}" if entry
+	    cc_cmd << cc_cmd_args
+	    cc_cmd
+	end
+
+	def mcs_cmd_exe
+	    # Generate compilation command for mcs.
+	    cc_cmd = csc.dup
+	    cc_cmd << " -target:exe"
+	    cc_cmd << " -main:#{entry}" if entry
+	    cc_cmd << cc_cmd_args
+	    cc_cmd
+	end
+
+	# Generate command for DLL.
+	def cmd_dll
+	    send @csc_name + "_cmd_dll"
+	end
+
+	def cscc_cmd_dll
+	    cc_cmd = csc.dup
+	    cc_cmd << " -shared"
+	    cc_cmd << cc_cmd_args
+	    cc_cmd
+	end
+
+	def csc_cmd_dll
+	    cc_cmd = csc.dup
+	    cc_cmd << " /target:library"
+	    cc_cmd << cc_cmd_args
+	    cc_cmd
+	end
+
+	def mcs_cmd_dll
+	    cc_cmd = csc.dup
+	    cc_cmd << " -target:library"
+	    cc_cmd << cc_cmd_args
+	    cc_cmd
+	end
+
+	# Generate command for object file.
+	def cmd_object
+	    send @csc_name + "_cmd_object"
+	end
+
+	def cscc_cmd_object
+	    cc_cmd = csc.dup
+	    cc_cmd << " -c"
+	    cc_cmd << cc_cmd_args
+	    cc_cmd
+	end
+
+	def csc_cmd_object
+	    cc_cmd = csc.dup
+	    cc_cmd << " /target:module"
+	    cc_cmd << cc_cmd_args
+	    cc_cmd
+	end
+
+	def mcs_cmd_object
+	    cc_cmd = csc.dup
+	    cc_cmd << " -target:module"
+	    cc_cmd << cc_cmd_args
+	    cc_cmd
+	end
+
+	def to_s
+	    csc + "\n" + "Interface: " + csc_name
+	end
+
+	private
+	def cc_cmd_args
+	    send @csc_name + "_cmd_args"
+	end
+
+	def cscc_cmd_args
+	    cc_args = ""
+	    cc_args << " -o #{out}" if out
+	    cc_args << " -g -DDEBUG" if debug
+	    defines.each { |p|
+		cc_args << " -D#{p}"
+	    }
+	    cc_args << " -Wall" if warnings
+	    cc_args << " -O2" if optimize
+	    lib_link_pathes.each { |p|
+		cc_args << " -L #{Env.shell_path(p)}"
+	    }
+	    libs.each { |p|
+		cc_args << " -l #{Env.shell_path(p)}"
+	    }
+	    cc_args << " " << misc_args.join(' ') if misc_args
+	    sargs = specific_args["cscc"]
+	    cc_args << " " << sargs.join(' ') if sargs
+	    resources.each { |p|
+		cc_args << " -fresources=#{Env.shell_path(p)}"
+	    }
+	    cc_args << " " << sources.arglist if sources
+	    cc_args
+	end
+
+	def csc_cmd_args
+	    cc_args = ""
+	    cc_args << " /out:#{Env.shell_path(out)}" if out
+	    cc_args << " /debug /d:DEBUG" if debug
+	    defines.each { |p|
+		cc_args << " /d:#{p}"
+	    }
+	    cc_args << " /optimize" if optimize
+	    # TODO: cc_args << " -Wall" if warnings
+	    lib_link_pathes.each { |p|
+		#TODO:    cc_args << " -L #{p}"
+	    }
+	    libs.each { |p|
+		cc_args << " /r:#{Env.shell_path(p)}"
+	    }
+	    cc_args << " " << misc_args.join(' ') if misc_args
+	    sargs = specific_args["csc"]
+	    cc_args << " " << sargs.join(' ') if sargs
+	    resources.each { |p|
+		cc_args << " /res:#{Env.shell_path(p)}"
+	    }
+	    cc_args << " " << sources.arglist if sources
+	    cc_args
+	end
+
+	def mcs_cmd_args
+	    cc_args = ""
+	    cc_args << " -o #{Env.shell_path(out)}" if out
+	    cc_args << " -g -d:DEBUG" if debug
+	    defines.each { |p|
+		cc_args << " -d:#{p}"
+	    }
+	    cc_args << " -optimize" if optimize
+	    # Warning level for mcs: highest 4, default 2
+	    cc_args << " -warn:4" if warnings
+	    lib_link_pathes.each { |p|
+		cc_args << " -L #{Env.shell_path(p)}"
+	    }
+	    if libs && !libs.empty?
+		cc_args << " -r:" + (libs.collect { |p| Env.shell_path(p) }).join(',')
+	    end
+	    cc_args << " " << misc_args.join(' ') if misc_args
+	    sargs = specific_args["mcs"]
+	    cc_args << " " << sargs.join(' ') if sargs
+	    resources.each { |p|
+		cc_args << " -resource:#{Env.shell_path(p)}"
+	    }
+	    cc_args << " " << sources.arglist if sources
+	    cc_args
+	end
+
+    end	# class CsCompiler
+end	# module Rant

data/lib/rant/import.rb

@@ -0,0 +1,291 @@
+
+# import.rb - Library for the rant-import command.
+#
+# Copyright (C) 2005 Stefan Lang <langstefan@gmx.at>
+
+require 'getoptlong'
+require 'rant/rantlib'
+
+module Rant
+
+    class RantImportDoneException < RantDoneException
+    end
+
+    class RantImportAbortException < RantAbortException
+    end
+
+    # This class is the implementation for the rant-import command.
+    # Usage similar to RantApp class.
+    class RantImport
+	include Rant::Console
+
+	# TODO: We currently only look for imports and plugins
+	# relative to this LIB_DIR. We should also look in all pathes
+	# in $LOAD_PATH after looking in LIB_DIR.
+	LIB_DIR = File.expand_path(File.dirname(__FILE__))
+
+	OPTIONS = [
+	    [ "--help",		"-h",	GetoptLong::NO_ARGUMENT,
+		"Print this help and exit."			],
+	    [ "--version",	"-v",	GetoptLong::NO_ARGUMENT,
+		"Print version of rant-import and exit."	],
+	    [ "--plugins",	"-p",	GetoptLong::REQUIRED_ARGUMENT,
+		"Include PLUGINS (comma separated list)."	],
+	    [ "--imports",	"-i",	GetoptLong::REQUIRED_ARGUMENT,
+		"Include IMPORTS (coma separated list)."	],
+	    [ "--force",		GetoptLong::NO_ARGUMENT,
+		"Force overwriting of output file."		],
+	    [ "--with-comments",	GetoptLong::NO_ARGUMENT,
+		"Include comments from Rant sources."		],
+	    [ "--reduce-whitespace", "-r",GetoptLong::NO_ARGUMENT,
+		"Remove as much whitespace from Rant sources as possible." ],
+	    [ "--auto",		"-a",	GetoptLong::NO_ARGUMENT,
+		"Automatically try to determine imports and plugins.\n" +
+		"Warning: loads Rantfile!"			],
+	    [ "--rantfile",	"-f",	GetoptLong::REQUIRED_ARGUMENT,
+		"Load RANTFILE. This also sets --auto!\n" +
+		"May be given multiple times."			],
+	]
+
+	class << self
+	    def run(first_arg=nil, *other_args)
+		other_args = other_args.flatten
+		args = first_arg.nil? ? ARGV.dup : ([first_arg] + other_args)
+		new(args).run
+	    end
+	end
+
+	# Arguments, usually those given on commandline.
+	attr :args
+	# Plugins to import.
+	attr :plugins
+	# Imports to import ;)
+	attr :imports
+	# Filename where the monolithic rant script goes to.
+	attr :mono_fn
+	# Skip comments? Defaults to true.
+	attr_accessor :skip_comments
+	# Remove whitespace from Rant sources? Defaults to false.
+	attr_accessor :reduce_whitespace
+	# Try automatic determination of imports and plugins?
+	# Defaults to false.
+	attr_accessor :auto
+
+	def initialize(*args)
+	    @args = args.flatten
+	    @msg_prefix = "rant-import: "
+	    @plugins = []
+	    @imports = []
+	    @mono_fn = nil
+	    @force = false
+	    @rantapp = nil
+	    @core_imports = []
+	    @included_plugins = []
+	    @included_imports = []
+	    @skip_comments = true
+	    @reduce_whitespace = false
+	    @auto = false
+	    @arg_rantfiles = []
+	end
+
+	def run
+	    process_args
+
+	    if @auto
+		@rantapp = RantApp.new(
+		    %w(-v --stop-after-load) +
+		    @arg_rantfiles.collect { |rf| "-f#{rf}" }
+		    )
+		unless @rantapp.run == 0
+		    abort("Auto-determination of required code failed.")
+		end
+		@imports.concat(@rantapp.imports)
+		@plugins.concat(@rantapp.plugins.map { |p| p.name })
+	    end
+	    
+	    if File.exist?(@mono_fn) && !@force
+		abort("#{@mono_fn} exists. Rant won't overwrite this file.",
+		    "Add --force to override this restriction.")
+	    end
+	    File.open(@mono_fn, "w") { |mf|
+		mf << <<EOH
+#!/usr/bin/env ruby
+
+# #@mono_fn - Monolithic rant script, autogenerated by rant-import.
+#
+# 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.
+EOH
+		mf << mono_rant_core
+		mf << mono_imports
+		mf << mono_plugins
+		mf << <<EOF
+
+Rant::CODE_IMPORTS.concat %w(#{@included_imports.join(' ')}
+    #{(@included_plugins.map do |i| "plugin/" + i end).join(' ')})
+
+# Catch a `require "rant"', sad...
+alias require_backup_by_rant require
+def require libf
+    if libf == "rant"
+	self.class.instance_eval { include Rant }
+    else
+	begin
+	    require_backup_by_rant libf
+	rescue
+	    raise $!, caller
+	end
+    end
+end
+
+Rant.run
+EOF
+	    }
+	    msg "Done.",
+		"Included imports: " + @included_imports.join(', '),
+		"Included plugins: " + @included_plugins.join(', '),
+		"Your monolithic rant was written to `#@mono_fn'!"
+	    
+	    done
+	rescue RantImportDoneException
+	    0
+	rescue RantImportAbortException
+	    $stderr.puts "rant-import aborted!"
+	    1
+	end
+
+	def process_args
+	    # WARNING: we currently have to fool getoptlong,
+	    # by temporory changing ARGV!
+	    # This could cause problems.
+	    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 "--version"
+		    puts "rant-import #{Rant::VERSION}"
+		    done
+		when "--help": help
+		when "--force": @force = true
+		when "--with-comments": @skip_comments = false
+		when "--reduce-whitespace": @reduce_whitespace = true
+		when "--imports"
+		    @imports.concat(value.split(/\s*,\s*/))
+		when "--plugins"
+		    @plugins.concat(value.split(/\s*,\s*/))
+		when "--auto"
+		    @auto = true
+		when "--rantfile"
+		    @auto = true
+		    @arg_rantfiles << value.dup
+		end
+	    }
+	    rem_args = ARGV.dup
+	    unless rem_args.size == 1 && !@mono_fn
+		abort("Exactly one argument (besides options) required.",
+		    "Type `rant-import --help' for usage.")
+	    end
+	    @mono_fn = rem_args.first if rem_args.first
+	rescue GetoptLong::Error => e
+	    abort(e.message)
+	ensure
+	    ARGV.replace(old_argv)
+	end
+
+	def done
+	    raise RantImportDoneException
+	end
+
+	def help
+	    puts "rant-import [OPTIONS] [-i IMPORT1,IMPORT2,...] [-p PLUGIN1,PLUGIN2...] MONO_RANT"
+	    puts
+	    puts "  Write a monolithic rant script to MONO_RANT."
+	    puts
+	    puts "Options are:"
+	    print option_listing(OPTIONS)
+	    done
+	end
+
+	def abort(*text)
+	    err_msg(*text) unless text.empty?
+	    raise RantImportAbortException
+	end
+
+	# Get a monolithic rant script (as string) containing only the
+	# Rant core.
+	def mono_rant_core
+	    # Starting point is rant/rantlib.rb.
+	    rantlib_f = File.join(LIB_DIR, "rantlib.rb")
+	    begin
+		rantlib = File.read rantlib_f
+	    rescue
+		abort("When trying to read `#{rantlib_f}': #$!",
+		    "This file should contains the core of rant, so import is impossible.",
+		    "Please check your rant installation!")
+	    end
+	    @core_imports << "rantlib"
+	    resolve_requires rantlib
+	end
+
+	def mono_imports
+	    rs = ""
+	    @imports.each { |name|
+		next if @included_imports.include? name
+		path = File.join(LIB_DIR, "import", "#{name}.rb")
+		unless File.exist? path
+		    abort("No such import - #{name}")
+		end
+		msg "Including import `#{name}'", path
+		@included_imports << name.dup
+		rs << resolve_requires(File.read(path))
+	    }
+	    rs
+	end
+
+	def mono_plugins
+	    rs = ""
+	    @plugins.each { |name|
+		lc_name = name.downcase
+		next if @included_plugins.include? lc_name
+		path = File.join(LIB_DIR, "plugin", "#{lc_name}.rb")
+		unless File.exist? path
+		    abort("No such plugin - #{name}")
+		end
+		msg "Including plugin `#{lc_name}'", path
+		@included_plugins << lc_name
+		rs << resolve_requires(File.read(path))
+	    }
+	    rs
+	end
+
+	# +script+ is a string. This method resolves requires of rant/
+	# code by directly inserting the code.
+	def resolve_requires script
+	    rs = ""
+	    script.each { |line|
+		# skip shebang line
+		next if line =~ /^#! ?(\/|\\)?\w/
+		# skip pure comment lines
+		next if line =~ /^\s*#/ if @skip_comments
+		if line =~ /\s*(require|load)\s+('|")rant\/(\w+)(\.rb)?('|")/
+		    name = $3
+		    next if @core_imports.include? name
+		    path = File.join(LIB_DIR, "#{name}.rb")
+		    msg "Including `#{name}'", path
+		    @core_imports << name
+		    rs << resolve_requires(File.read(path))
+		else
+		    line.sub!(/^\s+/, '') if @reduce_whitespace
+		    rs << line
+		end
+	    }
+	    rs
+	end
+
+    end	# class RantImport
+end	# module Rant