|
|
|
|
|
|
|
|
|
|
|
|
|
|
local workdir = getWorkingDirectory() |
|
|
|
|
|
local config = { |
|
|
PREFIX = workdir..[[\luarocks]], |
|
|
WIN_TOOLS = workdir..[[\luarocks\tools]], |
|
|
SYSCONFDIR = workdir..[[\luarocks]], |
|
|
LUA_DIR = workdir..[[\luajit]], |
|
|
LUA_INCDIR = workdir..[[\luajit\inc]], |
|
|
LUA_LIBDIR = workdir..[[\luajit\lib]], |
|
|
LUA_BINDIR = workdir..[[\luajit\bin]], |
|
|
LUA_INTERPRETER = [[luajit.exe]], |
|
|
SYSTEM = [[windows]], |
|
|
PROCESSOR = [[x86]], |
|
|
FORCE_CONFIG = true, |
|
|
} |
|
|
|
|
|
local function rewrite_hardcoded_config() |
|
|
local hc = assert(io.open(config.PREFIX..[[\lua\luarocks\core\hardcoded.lua]], 'w')) |
|
|
hc:write('return {\n') |
|
|
for k, v in pairs(config) do |
|
|
if type(v) == 'string' then |
|
|
hc:write(('\t%s = [[%s]],\n'):format(k, v)) |
|
|
else |
|
|
hc:write(('\t%s = %s,\n'):format(k, v)) |
|
|
end |
|
|
end |
|
|
hc:write('}\n') |
|
|
hc:close() |
|
|
end |
|
|
|
|
|
local function configure() |
|
|
local f = io.open(workdir..[[\luarocks\path.txt]], 'r') |
|
|
local path |
|
|
if f then |
|
|
path = f:read('*all') |
|
|
f:close() |
|
|
end |
|
|
if workdir ~= path then |
|
|
rewrite_hardcoded_config() |
|
|
f = assert(io.open(workdir..[[\luarocks\path.txt]], 'w')) |
|
|
f:write(workdir) |
|
|
f:close() |
|
|
end |
|
|
end |
|
|
|
|
|
local function parse_package_string(dep) |
|
|
local verpos = dep:find('@[^@]*$') |
|
|
local version, server |
|
|
if verpos then |
|
|
version = dep:sub(verpos + 1) |
|
|
dep = dep:sub(1, verpos - 1) |
|
|
end |
|
|
local srvpos = dep:find(':[^:]*$') |
|
|
if srvpos then |
|
|
server = dep:sub(1, srvpos - 1) |
|
|
dep = dep:sub(srvpos + 1) |
|
|
end |
|
|
local name = dep |
|
|
return name, version, server |
|
|
end |
|
|
|
|
|
local function concat_args(sep, ...) |
|
|
local strings = {} |
|
|
for i, v in ipairs({...}) do |
|
|
table.insert(strings, tostring(v)) |
|
|
end |
|
|
return table.concat(strings, sep) |
|
|
end |
|
|
|
|
|
local function shallow_copy(t, dest) |
|
|
local copy = dest or {} |
|
|
for k, v in pairs(t) do |
|
|
copy[k] = v |
|
|
end |
|
|
return copy |
|
|
end |
|
|
|
|
|
local package_backup |
|
|
local function create_luarocks_environment() |
|
|
local env = {errorlog={},require=require,coroutine={wrap=coroutine.wrap,yield=coroutine.yield,resume=coroutine.resume,status=coroutine.status,isyieldable=coroutine.isyieldable,running=coroutine.running,create=coroutine.create},assert=assert,tostring=tostring,tonumber=tonumber,io={input=io.input,stdin=io.stdin,tmpfile=io.tmpfile,read=io.read,output=io.output,open=io.open,close=io.close,write=io.write,popen=io.popen,flush=io.flush,type=io.type,lines=io.lines,stdout=io.stdout,stderr=io.stderr},rawget=rawget,xpcall=xpcall,ipairs=ipairs,print=print,pcall=pcall,gcinfo=gcinfo,module=module,setfenv=setfenv,jit={arch=jit.arch,version=jit.version,version_num=jit.version_num,status=jit.status,on=jit.on,os=jit.os,off=jit.off,flush=jit.flush,attach=jit.attach,opt={start=jit.opt.start}},pairs=pairs,bit={rol=bit.rol,rshift=bit.rshift,ror=bit.ror,bswap=bit.bswap,bxor=bit.bxor,bor=bit.bor,arshift=bit.arshift,bnot=bit.bnot,tobit=bit.tobit,lshift=bit.lshift,tohex=bit.tohex,band=bit.band},debug={setupvalue=debug.setupvalue,getregistry=debug.getregistry,traceback=debug.traceback,setlocal=debug.setlocal,getupvalue=debug.getupvalue,gethook=debug.gethook,sethook=debug.sethook,getlocal=debug.getlocal,upvaluejoin=debug.upvaluejoin,getinfo=debug.getinfo,getfenv=debug.getfenv,setmetatable=debug.setmetatable,upvalueid=debug.upvalueid,getuservalue=debug.getuservalue,debug=debug.debug,getmetatable=debug.getmetatable,setfenv=debug.setfenv,setuservalue=debug.setuservalue},package=package,error=error,load=load,loadfile=loadfile,rawequal=rawequal,string={find=string.find,format=string.format,rep=string.rep,gsub=string.gsub,len=string.len,gmatch=string.gmatch,dump=string.dump,match=string.match,reverse=string.reverse,byte=string.byte,char=string.char,upper=string.upper,lower=string.lower,sub=string.sub},unpack=unpack,table={maxn=table.maxn,move=table.move,pack=table.pack,foreach=table.foreach,sort=table.sort,remove=table.remove,foreachi=table.foreachi,getn=table.getn,concat=table.concat,insert=table.insert},_VERSION=_VERSION,newproxy=newproxy,dofile=dofile,collectgarbage=collectgarbage,loadstring=loadstring,next=next,math={ceil=math.ceil,tan=math.tan,log10=math.log10,randomseed=math.randomseed,cos=math.cos,sinh=math.sinh,random=math.random,huge=math.huge,pi=math.pi,max=math.max,atan2=math.atan2,ldexp=math.ldexp,floor=math.floor,sqrt=math.sqrt,deg=math.deg,atan=math.atan,fmod=math.fmod,acos=math.acos,pow=math.pow,abs=math.abs,min=math.min,sin=math.sin,frexp=math.frexp,log=math.log,tanh=math.tanh,exp=math.exp,modf=math.modf,cosh=math.cosh,asin=math.asin,rad=math.rad},rawset=rawset,os={execute=os.execute,rename=os.rename,setlocale=os.setlocale,getenv=os.getenv,difftime=os.difftime,remove=os.remove,date=os.date,exit=os.exit,time=os.time,clock=os.clock,tmpname=os.tmpname},select=select,rawlen=rawlen,type=type,getmetatable=getmetatable,getfenv=getfenv,setmetatable=setmetatable} |
|
|
env._G = env |
|
|
|
|
|
|
|
|
|
|
|
package_backup = shallow_copy(package) |
|
|
package_backup.preload = shallow_copy(package.preload) |
|
|
package_backup.loaded = shallow_copy(package.loaded) |
|
|
package_backup.loaders = shallow_copy(package.loaders) |
|
|
package_backup.searchers = package_backup.loaders |
|
|
package_backup.loaded._G = env |
|
|
env.package.path = ([[%s\lua\?.lua;%s\lua\?\init.lua]]):format(config.PREFIX, config.PREFIX) |
|
|
env.package.cpath = config.PREFIX..'\\?.dll' |
|
|
return env |
|
|
end |
|
|
|
|
|
local function initialize_luarocks() |
|
|
|
|
|
local util = require('luarocks.util') |
|
|
util.warning = function(msg) |
|
|
if msg and #tostring(msg) > 0 then |
|
|
print('[luarocks] [warning]', msg) |
|
|
end |
|
|
end |
|
|
util.printerr = function(...) |
|
|
local str = concat_args(' ', ...) |
|
|
if #str > 0 then |
|
|
table.insert(errorlog, str) |
|
|
print('[luarocks] [error]', str) |
|
|
end |
|
|
end |
|
|
util.printout = function(...) |
|
|
local str = concat_args(' ', ...) |
|
|
if #str > 0 then |
|
|
print('[luarocks]', str) |
|
|
end |
|
|
end |
|
|
|
|
|
local cfg = require('luarocks.core.cfg') |
|
|
require('luarocks.loader') |
|
|
local fs = require('luarocks.fs') |
|
|
local ok, err = cfg.init() |
|
|
if not ok then |
|
|
error(err) |
|
|
end |
|
|
fs.init() |
|
|
end |
|
|
|
|
|
local luarocks |
|
|
local function run_luarocks(fn, ...) |
|
|
if not luarocks then |
|
|
luarocks = create_luarocks_environment() |
|
|
setfenv(initialize_luarocks, luarocks) |
|
|
initialize_luarocks() |
|
|
end |
|
|
setfenv(fn, luarocks) |
|
|
return fn(...) |
|
|
end |
|
|
|
|
|
local function test_installed_package(name, version) |
|
|
return run_luarocks(function() |
|
|
local queries = require('luarocks.queries') |
|
|
local search = require('luarocks.search') |
|
|
|
|
|
local query = queries.new(name:lower(), version, nil, nil, '>=') |
|
|
local rock_name, rock_version = search.pick_installed_rock(query) |
|
|
if rock_name then |
|
|
return true |
|
|
end |
|
|
|
|
|
if rock_version:find('cannot find package') then |
|
|
return false |
|
|
end |
|
|
error(rock_version) |
|
|
end) |
|
|
end |
|
|
|
|
|
local function find_rock_tree(trees, name) |
|
|
for _, tree in ipairs(trees) do |
|
|
if type(tree) == 'table' and name == tree.name then |
|
|
if not tree.root then |
|
|
error('Configuration error: tree "'..tree.name..'" has no "root" field.') |
|
|
end |
|
|
return tree |
|
|
end |
|
|
end |
|
|
end |
|
|
|
|
|
local luarocks_install_flags |
|
|
local function install_package(name, version, server) |
|
|
if server and not server:match('^[^:]+://(.*)') then |
|
|
server = 'http://luarocks.org/manifests/'..server |
|
|
end |
|
|
return run_luarocks(function() |
|
|
if not luarocks_install_flags then |
|
|
local dir = require('luarocks.dir') |
|
|
local path = require('luarocks.path') |
|
|
local cfg = require('luarocks.core.cfg') |
|
|
local flags = { |
|
|
['deps-mode'] = 'order', |
|
|
['no-doc'] = true, |
|
|
['timeout'] = 10, |
|
|
} |
|
|
cfg.connection_timeout = 10 |
|
|
|
|
|
local tree = find_rock_tree(cfg.rocks_trees, 'lib') |
|
|
if not tree then |
|
|
error('Configuration error: no tree "lib".') |
|
|
end |
|
|
flags['tree'] = dir.normalize(tree.root) |
|
|
path.use_tree(tree) |
|
|
cfg.variables.ROCKS_TREE = cfg.rocks_dir |
|
|
cfg.variables.SCRIPTS_DIR = cfg.deploy_bin_dir |
|
|
|
|
|
default_rock_servers = cfg.rocks_servers |
|
|
luarocks_install_flags = flags |
|
|
end |
|
|
local cfg |
|
|
if server then |
|
|
cfg = require('luarocks.core.cfg') |
|
|
local util = require('luarocks.core.util') |
|
|
cfg.rocks_servers = shallow_copy(default_rock_servers) |
|
|
table.insert(cfg.rocks_servers, 1, server) |
|
|
end |
|
|
local install = require('luarocks.cmd.install') |
|
|
local ok, err = install.command(luarocks_install_flags, name, version) |
|
|
if not ok then |
|
|
error(err) |
|
|
end |
|
|
if server then |
|
|
cfg.rocks_servers = default_rock_servers |
|
|
end |
|
|
return true |
|
|
end) |
|
|
end |
|
|
|
|
|
local function run_scheduled_functions() |
|
|
run_luarocks(function() |
|
|
local util = require('luarocks.util') |
|
|
util.run_scheduled_functions() |
|
|
end) |
|
|
end |
|
|
|
|
|
local ffi |
|
|
local function msgbox(text, title, style) |
|
|
if not ffi then |
|
|
ffi = require('ffi') |
|
|
ffi.cdef [[int MessageBoxA(void* hWnd, const char* lpText, const char* lpCaption, unsigned int uType);]] |
|
|
end |
|
|
local hwnd = nil |
|
|
if readMemory then |
|
|
|
|
|
hwnd = ffi.cast('void*', readMemory(0x00C8CF88, 4, false)) |
|
|
end |
|
|
showCursor(true) |
|
|
local ret = ffi.C.MessageBoxA(hwnd, text, '[MoonLoader] '..script.this.filename..': '..title, (style or 0) + 0x50000) |
|
|
showCursor(false) |
|
|
return ret |
|
|
end |
|
|
|
|
|
local function failure(msg) |
|
|
if luarocks_install_flags then |
|
|
run_scheduled_functions() |
|
|
end |
|
|
if luarocks then |
|
|
local errorlog = table.concat(luarocks.errorlog, '\n') |
|
|
msg = errorlog..'\n'..msg |
|
|
end |
|
|
msgbox(msg, 'Failed to install dependencies', 0x10) |
|
|
error(msg) |
|
|
end |
|
|
|
|
|
local function cleanup() |
|
|
shallow_copy(package_backup, package) |
|
|
package_backup = nil |
|
|
luarocks = nil |
|
|
luarocks_install_flags = nil |
|
|
collectgarbage() |
|
|
collectgarbage() |
|
|
end |
|
|
|
|
|
local function batch_install(packages) |
|
|
print('Requested packages: '..table.concat(packages, ', ')) |
|
|
local to_install = {} |
|
|
local time_test, time_install = os.clock(), nil |
|
|
for i, dep in ipairs(packages) do |
|
|
local name, version, server = parse_package_string(dep) |
|
|
local ok, result = pcall(test_installed_package, name, version) |
|
|
if ok then |
|
|
if result == false then |
|
|
table.insert(to_install, {name = name, ver = version, svr = server, full = dep}) |
|
|
end |
|
|
else |
|
|
failure(dep..'\n'..result) |
|
|
end |
|
|
end |
|
|
time_test = os.clock() - time_test |
|
|
if #to_install > 0 then |
|
|
local list = '' |
|
|
for i, pkg in ipairs(to_install) do |
|
|
list = list..pkg.full..'\n' |
|
|
end |
|
|
if 7 == msgbox('Script "'..script.this.filename..'" asks to install the following packages:\n\n'.. |
|
|
list..'\nInstallation process will take some time.\nProceed?', 'Package installation', 0x04 + 0x20 ) |
|
|
then |
|
|
error('Dependency installation was interrupted by user.') |
|
|
end |
|
|
time_install = os.clock() |
|
|
for i, pkg in ipairs(to_install) do |
|
|
local ok, err = pcall(install_package, pkg.name, pkg.ver, pkg.svr) |
|
|
if not ok then |
|
|
failure(pkg.full..'\n'..err) |
|
|
end |
|
|
end |
|
|
time_install = os.clock() - time_install |
|
|
end |
|
|
|
|
|
local dbgmsg = ('Installed check took %.3fs.'):format(time_test) |
|
|
if #to_install > 0 then |
|
|
logdebug(dbgmsg, ('Installation of %d packages took %.2fs. Total %.2fs.'):format(#to_install, time_install, time_test + time_install)) |
|
|
run_scheduled_functions() |
|
|
|
|
|
coroutine.yield() |
|
|
else |
|
|
logdebug(dbgmsg) |
|
|
end |
|
|
cleanup() |
|
|
end |
|
|
|
|
|
|
|
|
|
|
|
local mod = { |
|
|
_VERSION = '0.2.0' |
|
|
} |
|
|
|
|
|
function mod.install(...) |
|
|
return batch_install({...}) |
|
|
end |
|
|
|
|
|
function mod.test(...) |
|
|
local results = {} |
|
|
for i, dep in ipairs({...}) do |
|
|
local name, version, server = parse_package_string(dep) |
|
|
local ok, result = pcall(test_installed_package, name, version) |
|
|
if not ok then |
|
|
cleanup() |
|
|
return nil, result |
|
|
end |
|
|
results[dep] = result |
|
|
end |
|
|
cleanup() |
|
|
return results |
|
|
end |
|
|
|
|
|
setmetatable(mod, { |
|
|
__call = function(t, a1, ...) |
|
|
if type(a1) == 'table' then |
|
|
return batch_install(a1) |
|
|
end |
|
|
return batch_install({a1, ...}) |
|
|
end |
|
|
}) |
|
|
|
|
|
configure() |
|
|
|
|
|
return mod |
|
|
|
