Lua: make module system - module

Question

I want to create a program which will have several modules in different folders. Main program will determine which module need to load and will load it. Beside it will load some core functions too.
I created prototype of this logic and it works good.
But since I'm new in Lua, I'm not sure what went right way to implement this.
For now I have next structure of files:
aoc (main program):
aoc = {}
aoc_base_path = debug.getinfo(1).source:match("#(.*)/.*$") -- base path to my program
if not aoc_base_path then
aoc_base_path = ''
else
aoc_base_path = aoc_base_path..'/'
end
local aoc_base_arg={...}
dofile(aoc_base_path.."core/core")
local module = assert(loadfile(aoc_base_path.."modules/"..aoc_base_arg[1].."/module"))
local arg = table.copy(aoc_base_arg) -- this is my custom function (I'm not provide you with listing, it just copy one table to another one
table.remove(arg,1)
module(arg,aoc) -- pass to module all arguments except first one
core/core (core functions loader):
dofile (aoc_base_path..'core/move')
core/move:
local function move(direction, refuel, dig, attack)
-- some logic in local function (to not be overwriten in module)
end
function aoc.move()
-- global function (it logic can be changed by module in case it needed)
return move()
end
modules/mine/module (module):
local arg={...} -- I passed 2 arguments in aoc main program
arg = arg[1]
local aoc = arg[2]
aoc.move()
For now
lua> aoc mine
or
lua> path/to/aoc mine
work OK. But can anyone point me if I doing something wrong?
EDIT: changed logic with getting aoc_base_path

Answer 1

You can simplify aoc a bit:
aoc = {}
aoc_base_path = debug.getinfo(1).source:match("#(.*/)") or ''
dofile(aoc_base_path.."core/core")
local module = assert(loadfile(aoc_base_path.."modules/".. ... .."/module"))
module({select(2,...)},aoc)

Answer 2

Just use Lua's library built-in module functionality with require. With proper set-up of package.loaders you can configure this standard system to load modules from wherever you want and in any manner you want. Specific directories, directly from HTTP, delivered by pigeons according to RFC 1149 - it can do it all.

Answer 3

To keep your directory structure more or less the same but make use of the lua package system you could use an approach like this:
In your base path have a file aoc.lua:
local aoc = {}
local module = ...
local dir = module:gsub("%.","%/"):sub(1,-4)
package.path = dir.."?.lua;"..package.path
package.path = dir.."?/init.lua;"..package.path
package.path = dir.."modules/?.lua;"..package.path
return aoc
In /core have a file init.lua that requires the core packages that you want to include
require"core.move"
Then your core packages will look something like:
local function move(direction, refuel, dig, attack)
-- some logic in local function (to not be overwriten in module)
end
require"aoc".move = move
In /modules you can then make things a bit simpler by having a lua file for each module so /modules/mine.lua would look like:
local aoc = require"aoc"
aoc.move()
Then at the lua prompt you'd write:
lua> require"path.to.aoc"
lua> require"core" --load up the core modules
lua> require"mine" -- load mine
Edit
If you want to maintain identically the same style, change aoc.lua to be just return {} and add a file aoc as follows:
local dir = debug.getinfo(1).source:match("#(.*)/.*$") -- base path to my program
if not dir then dir = ''
else dir = dir..'/'
end
package.path = dir.."?.lua;"..package.path
package.path = dir.."?/init.lua;"..package.path
package.path = dir.."modules/?.lua;"..package.path
require"core"
for _,mod in ipairs{...} do
require(mod)
end
I would suggest that the advantage of this approach is that all of the mangling is in one file, aoc in this case, and the rest of the file structure is using fairly standard lua package conventions.