main.hx

ocaml编写的一个flash编译器

		var h = new haxe.Http(siteUrl+Datas.REPOSITORY+"/"+filename);
		h.onError = function(e) {
			progress.close();
			neko.FileSystem.deleteFile(filepath);
			throw e;
		};
		print("Downloading "+filename+"...");
		h.asyncRequest(false,progress);

		doInstallFile(filepath,setcurrent);
	}

	function doInstallFile(filepath,setcurrent,?nodelete) {

		// read zip content
		var f = neko.io.File.read(filepath,true);
		var zip = neko.zip.File.readZip(f);
		f.close();
		var infos = Datas.readInfos(zip);

		// create directories
		var pdir = getRepository() + Datas.safe(infos.project);
		safeDir(pdir);
		pdir += "/";
		var target = pdir + Datas.safe(infos.version);
		safeDir(target);
		target += "/";

		// locate haxelib.xml base path
		var basepath = null;
		for( f in zip ) {
			if( StringTools.endsWith(f.fileName,Datas.XML) ) {
				basepath = f.fileName.substr(0,f.fileName.length - Datas.XML.length);
				break;
			}
		}
		if( basepath == null )
			throw "No "+Datas.XML+" found";

		// unzip content
		for( zipfile in zip ) {
			var n = zipfile.fileName;
			if( StringTools.startsWith(n,basepath) ) {
				// remove basepath
				n = n.substr(basepath.length,n.length-basepath.length);
				if( n.charAt(0) == "/" || n.charAt(0) == "\\" || n.split("..").length > 1 )
					throw "Invalid filename : "+n;
				var dirs = ~/[\/\\]/g.split(n);
				var path = "";
				var file = dirs.pop();
				for( d in dirs ) {
					path += d;
					safeDir(target+path);
					path += "/";
				}
				if( file == "" ) {
					if( path != "" ) print("  Created "+path);
					continue; // was just a directory
				}
				path += file;
				print("  Install "+path);
				var data = neko.zip.File.unzip(zipfile);
				var f = neko.io.File.write(target+path,true);
				f.write(data);
				f.close();
			}
		}

		// set current version
		if( setcurrent || !neko.FileSystem.exists(pdir+".current") ) {
			var f = neko.io.File.write(pdir+".current",true);
			f.write(infos.version);
			f.close();
			print("  Current version is now "+infos.version);
		}

		// end
		if( !nodelete )
			neko.FileSystem.deleteFile(filepath);
		print("Done");

		// process dependencies
		for( d in infos.dependencies ) {
			print("Installing dependency "+d.project+" "+d.version);
			if( d.version == "" )
				d.version = site.infos(d.project).curversion;
			doInstall(d.project,d.version,false);
		}
	}

	function safeDir( dir ) {
		if( neko.FileSystem.exists(dir) ) {
			if( !neko.FileSystem.isDirectory(dir) )
				throw ("A file is preventing "+dir+" to be created");
			return false;
		}
		try {
			neko.FileSystem.createDirectory(dir);
		} catch( e : Dynamic ) {
			throw "You don't have enough user rights to create the directory "+dir;
		}
		return true;
	}

	function getRepository( ?setup : Bool ) {
		var sys = neko.Sys.systemName();
		if( sys == "Windows" ) {
			var haxepath = neko.Sys.getEnv("HAXEPATH");
			if( haxepath == null )
				throw "HAXEPATH environment variable not defined, please run haxesetup.exe first";
			var rep = haxepath+REPNAME;
			try {
				safeDir(rep);
			} catch( e : Dynamic ) {
				throw "The directory defined by HAXEPATH does not exist, please run haxesetup.exe again";
			}
			return rep+"\\";
		}
		var config = neko.Sys.getEnv("HOME")+"/.haxelib";
		var rep = try
			neko.io.File.getContent(config)
		catch( e : Dynamic ) try
			neko.io.File.getContent("/etc/.haxelib")
		catch( e : Dynamic )
			if( setup ) {
				if( sys == "Linux" ) "/usr/lib/haxe/"+REPNAME else "/usr/local/lib/haxe/"+REPNAME;
			} else
				throw "This is the first time you are runing haxelib. Please run haxelib setup first";
		if( setup ) {
			print("Please enter haxelib repository path with write access");
			print("Hit enter for default ("+rep+")");
			var line = param("Path");
			if( line != "" )
				rep = line;
			if( !neko.FileSystem.exists(rep) ) {
				try {
					neko.FileSystem.createDirectory(rep);
				} catch( e : Dynamic ) {
					print("Failed to create directory '"+rep+"' ("+Std.string(e)+"), maybe you need appropriate user rights");
					neko.Sys.exit(1);
				}
			}
			var f = neko.io.File.write(config,true);
			f.write(rep);
			f.close();
		} else if( !neko.FileSystem.exists(rep) )
			throw "haxelib Repository "+rep+" does not exists. Please run haxelib setup again";
		return rep+"/";
	}

	function setup() {
		var path = getRepository(true);
		print("haxelib repository is now "+path);
	}

	function config() {
		print(getRepository());
	}

	function list() {
		var rep = getRepository();
		for( p in neko.FileSystem.readDirectory(rep) ) {
			if( p.charAt(0) == "." )
				continue;
			var versions = new Array();
			var current = neko.io.File.getContent(rep+p+"/.current");
			for( v in neko.FileSystem.readDirectory(rep+p) ) {
				if( v.charAt(0) == "." )
					continue;
				v = Datas.unsafe(v);
				if( v == current )
					v = "["+v+"]";
				versions.push(v);
			}
			print(Datas.unsafe(p) + ": "+versions.join(" "));
		}
	}

	function upgrade() {
		var rep = getRepository();
		var prompt = true;
		var update = false;
		for( p in neko.FileSystem.readDirectory(rep) ) {
			if( p.charAt(0) == "." )
				continue;
			var p = Datas.unsafe(p);
			print("Checking "+p);
			var inf = site.infos(p);
			if( !neko.FileSystem.exists(rep+Datas.safe(p)+"/"+Datas.safe(inf.curversion)) ) {
				if( prompt )
					switch ask("Upgrade "+p+" to "+inf.curversion) {
					case Yes:
					case Always: prompt = false;
					case No: continue;
					}
				doInstall(p,inf.curversion,true);
				update = true;
			} else
				setCurrent(p,inf.curversion,true);
		}
		if( update )
			print("Done");
		else
			print("All projects are up-to-date");
	}

	function deleteRec(dir) {
		for( p in neko.FileSystem.readDirectory(dir) ) {
			var path = dir+"/"+p;
			if( neko.FileSystem.isDirectory(path) )
				deleteRec(path);
			else
				neko.FileSystem.deleteFile(path);
		}
		neko.FileSystem.deleteDirectory(dir);
	}

	function remove() {
		var prj = param("Project");
		var version = paramOpt();
		var rep = getRepository();
		var pdir = rep + Datas.safe(prj);

		if( version == null ) {
			if( !neko.FileSystem.exists(pdir) )
				throw "Project "+prj+" is not installed";
			deleteRec(pdir);
			print("Project "+prj+" removed");
			return;
		}

		var vdir = pdir + "/" + Datas.safe(version);
		if( !neko.FileSystem.exists(vdir) )
			throw "Project "+prj+" does not have version "+version+" installed";

		var cur = neko.io.File.getContent(pdir+"/.current");
		if( cur == version )
			throw "Can't remove current version of project "+prj;
		deleteRec(vdir);
		print("Project "+prj+" version "+version+" removed");
	}

	function set() {
		var prj = param("Project");
		var version = param("Version");
		setCurrent(prj,version,false);
	}

	function setCurrent( prj : String, version : String, doAsk : Bool ) {
		var pdir = getRepository() + Datas.safe(prj);
		var vdir = pdir + "/" + Datas.safe(version);
		if( !neko.FileSystem.exists(vdir) )
			throw "Project "+prj+" version "+version+" is not installed";
		var current = pdir+"/.current";
		if( neko.io.File.getContent(current) == version )
			return;
		if( doAsk && ask("Set "+prj+" to version "+version) == No )
			return;
		var f = neko.io.File.write(current,true);
		f.write(version);
		f.close();
		print("Project "+prj+" current version is now "+version);
	}

	function checkRec( prj : String, version : String, l : List<{ project : String, version : String }> ) {
		var pdir = getRepository() + Datas.safe(prj);
		if( !neko.FileSystem.exists(pdir) )
			throw "Project "+prj+" is not installed";
		var version = if( version != null ) version else neko.io.File.getContent(pdir+"/.current");
		var vdir = pdir + "/" + Datas.safe(version);
		if( !neko.FileSystem.exists(vdir) )
			throw "Project "+prj+" version "+version+" is not installed";
		for( p in l )
			if( p.project == prj ) {
				if( p.version == version )
					return;
				throw "Project "+prj+" has two version included "+version+" and "+p.version;
			}
		l.add({ project : prj, version : version });
		var xml = neko.io.File.getContent(vdir+"/haxelib.xml");
		var inf = Datas.readData(xml);
		for( d in inf.dependencies )
			checkRec(d.project,if( d.version == "" ) null else d.version,l);
	}

	function path() {
		var list = new List();
		while( argcur < args.length ) {
			var a = args[argcur++].split(":");
			checkRec(a[0],a[1],list);
		}
		var rep = getRepository();
		for( d in list ) {
			var pdir = Datas.safe(d.project)+"/"+Datas.safe(d.version)+"/";
			var dir = rep + pdir;
			var ndir = dir + "ndll";
			if( neko.FileSystem.exists(ndir) ) {
				var sysdir = ndir+"/"+neko.Sys.systemName();
				if( !neko.FileSystem.exists(sysdir) )
					throw "Project "+d.project+" version "+d.version+" does not have a neko dll for your system";
				neko.Lib.println("-L "+pdir+"ndll/");
			}
			neko.Lib.println(dir);
		}
	}

	function run() {
		var rep = getRepository();
		var project = param("Project");
		var pdir = rep + Datas.safe(project);
		if( !neko.FileSystem.exists(pdir) )
			throw "Project "+project+" is not installed";
		pdir += "/";
		var version = neko.io.File.getContent(pdir+".current");
		var vdir = pdir + Datas.safe(version);
		var rdir = vdir + "/run.n";
		if( !neko.FileSystem.exists(rdir) )
			throw "Project "+project+" version "+version+" does not have a run script";
		args.push(neko.Sys.getCwd());
		neko.Sys.setCwd(vdir);
		var cmd = "neko run.n";
		for( i in argcur...args.length )
			cmd += " "+escapeArg(args[i]);
		neko.Sys.exit(neko.Sys.command(cmd));
	}

	function escapeArg( a : String ) {
		if( a.indexOf(" ") == -1 )
			return a;
		return '"'+a+'"';
	}

	function test() {
		var file = param("Package");
		doInstallFile(file,true,true);
	}

	// ----------------------------------

	static function print(str) {
		neko.Lib.print(str+"\n");
	}

	static function main() {
		haxe.Http.PROXY = neko.net.ProxyDetect.detect();
		new Main().process();
	}

}