luapack.yue

require_pattern = [[require%s*%(?%s*(["'])(.-)%1]]

-- imports
-- !!! using an extra function here, so the require call isn't interruped by a comma
--     and the minifier gets luapacked
minifier = select 2, try -> require "lib/minifier"
yue = select 2, try require "yue"
moon = select 2, try require "moonscript.base"

-- helpers
fast_push = (tbl, item) ->
    tbl[tbl.n + 1] = item
    tbl.n += 1

class Writer
    new: =>
        @dept = 0
        @out = {n: 0}
    
    indent: => "\t"::rep @dept

    writeln: (text) => fast_push @out, "#{@indent!}#{text}"
    writelines: (text) => @writeln line for line in text::gmatch "[^\n]+"
    
    incr: => @dept += 1
    decr: => @dept -= 1
    wrap: (cb) =>
        @incr!
        cb!
        @decr!
    endwrap: (cb) =>
        @wrap cb
        @writeln "end"

    str: => table.concat @out, "\n"


searchpath_compat = (name, path) ->
    return package.searchpath name, path if package.searchpath -- lua 5.2+
    name = name::gsub "%.", "/" -- a.b.c -> a/b/c
    for path in path::gmatch "[^;]+"
        p = path::gsub "?", name
        -- very janky cross platform check to see if the file exists
        -- this janky check also somehow accepts directories
        -- because they can be opened??
        fh = io.open p, "r"
        if fh?
            fh::close!
            return p

package_path_with_different_extension = => package.path::gsub "%.lua", ".#{@}"
-- basically string:endswith
check_file_extension = (filename, ext) -> ext == filename::sub -#ext
replace_file_extension = (from_, to) => @gsub "%#{from_}$", to
escape_string = => @gsub "([%%%^%$%(%)%.%[%]%*%+%-%?])", "%%%1"

alias_factory = ->
  n = 0
  ->
    n += 1
    tostring n

export helpers = {
    :fast_push
    :searchpath_compat
    :package_path_with_different_extension
    :check_file_extension
    :escape_string
    :alias_factory
}
-- version info

export __author__ = "Leo Developer"
export __url__ = "https://github.com/le0developer/luapack"
export __license__ = "MIT"
export __version__ = "0.5.0-alpha0"

export default_plugins = {n: 0}

-- api interface:
--   searchpath(packer, name)
--     returns nil/false or a path to a file
--   loader(packer, name, content)
--     post-processing of the file
--     return lua code

fast_push default_plugins,
    name: "lua"
    searchpath: (_, name) -> searchpath_compat name, package.path

if "table" == type yue
    fast_push default_plugins,
        name: "yuescript"
        searchpath: (_, name) -> searchpath_compat name, package_path_with_different_extension "yue"
        loader: (_, _, filename, content) ->
            return false unless check_file_extension filename, ".yue"
            lua = yue.to_lua content, reserve_line_number: false
            lua, replace_file_extension filename, ".yue", ".lua"

if "table" == type moon
    fast_push default_plugins,
        name: "moonscript"
        searchpath: (_, name) -> searchpath_compat name, package_path_with_different_extension "moon"
        loader: (_, _, filename, content) ->
            return false unless check_file_extension filename, ".moon"
            lua = moon.to_lua content
            lua, replace_file_extension filename, ".moon", ".lua"


-- packer class

-- options:
--   minify = true
--   package_polyfill = false
--   with_header = true
--   clear_loaded = true
--   plugins = default_plugins
--   compat_arg = true
--   include_entry = true
--   entry_name = "__luapack_entry__"
--   package_preload_name = "package.preload"
--   package_loaded_name = "package.loaded"
--   alias = nil
export class Packer
    new: (@options = {}) =>
        @loaded = {}
        @aliases = {}

    _entry_name: => @options.entry_name or "__luapack_entry__"
    _package_preload_name: => @options.package_preload_name or "package.preload"
    _package_loaded_name: => @options.package_loaded_name or "package.loaded"

    extract_packages: (source) =>
        matches = {n: 0}
        fast_push matches, match for _, match in source::gmatch require_pattern
        matches

    extract_and_alias_packages: (source) =>
      packages = @extract_packages source
      return packages, source unless @options.alias?

      for package in *packages
        @aliases[package] = @options.alias package unless @aliases[package]?
        if @aliases[package]? -- alias function can return nil
          pattern = [[(["'])(%s)%%1]]::format escape_string package
          replace = [[%%1%s%%1]]::format escape_string @aliases[package]
          source = source::gsub pattern, replace
      packages, source

    include: (package_name, filename) =>
        plugins = @options.plugins or default_plugins
        plugin_index = 1
        while not filename?
            plugin = plugins[plugin_index]
            return unless plugin? -- all plugins failed
            if plugin.searchpath?
                filename = plugin.searchpath @, package_name
                break if filename? -- finally found the filename
            plugin_index += 1

        return if @loaded[package_name]? -- recursion
        -- return unless filename::match"%.lua$" -- not a lua file
        with fh = io.open filename, "r"
            error "file not found: #{filename}" unless fh?
            @loaded[package_name] = ::read"*a"
            ::close!

        -- post process
        for plugin in *plugins
            continue unless plugin.loader?
            new_content, new_filename = plugin.loader @, package_name, filename, @loaded[package_name]
            @loaded[package_name] = new_content if new_content
            filename = filename if new_filename

        return if "-- luapacked" == @loaded[package_name]::sub 1, 12 -- dont pack dependencies of a packed file

        packages, @loaded[package_name] = @extract_and_alias_packages @loaded[package_name]
        @include dependency for dependency in *packages

    pack: (entry) =>
        @include @_entry_name!, entry
        error "file not found: #{entry}" unless @loaded[@_entry_name!]?

        @loaded[@_entry_name!] = nil if @options.include_entry == false

    export: =>
        packed = @bootstrap!
        packed = minifier.Rebuild.MinifyString packed if @options.minify != false and "table" == type minifier
        header = ""
        if @options.with_header != false
            header = "-- luapacked using #{__version__}\n"
        header .. packed

    bootstrap: =>
        writer = Writer!
        if @options.compat_arg != false
            for package_name, content in pairs @loaded
                if content::match "%.%.%."
                    writer::writeln "local __luapack_arg__ = arg"
                    break

        if @options.package_polyfill
            duplicate_lines = {}
            ensure_parent = =>
              parents = @gmatch "[^%.]+"
              growing = ""
              for parent in parents
                obj = growing .. parent
                line = "if not %s then _G.%s = {} end"::format obj, obj
                unless duplicate_lines[line]?
                  writer::writeln line
                  duplicate_lines[line] = true
                growing ..= parent .. "."
            ensure_parent @_package_preload_name!
            ensure_parent @_package_loaded_name!
            writer::writeln "if not require then"
            writer::endwrap ->
                writer::writeln "local sentinel = {}" -- recursion detection
                writer::writeln "_G.require = function(modname)"
                writer::endwrap ->
                    writer::writeln "if %s[modname] == sentinel then"::format @_package_loaded_name!
                    writer::endwrap ->
                        writer::writeln 'error(("loop or previous error loading module %q"):format(modname), 0)'
                    writer::writeln "if %s[modname] ~= nil then return %s[modname] end"::format @_package_loaded_name!, @_package_loaded_name!
                    writer::writeln "if not %s[modname] then"::format @_package_preload_name!
                    writer::endwrap ->
                        writer::writeln 'error(("module not found %q"):format(modname), 2)'
                    writer::writeln "%s[modname] = sentinel"::format @_package_loaded_name!
                    writer::writeln 'local success, result = pcall(%s[modname], modname, ":preload:")'::format @_package_preload_name!
                    writer::writeln "if not success then"
                    writer::endwrap ->
                        writer::writeln "%s[modname] = nil"::format @_package_loaded_name! -- so it can be loaded again
                        writer::writeln "error(result)" -- rethrow error
                    writer::writeln "if result == nil then result = true end"
                    writer::writeln "%s[modname] = result"::format @_package_loaded_name!
                    writer::writeln 'return result, ":preload:"'

        already_loaded = {}
        for package_name, content in pairs @loaded
            name = @aliases[package_name] or package_name
            if already_loaded[content]
                writer::writeln "%s[%q] = %s[%q]"::format @_package_preload_name!, name, @_package_preload_name!, already_loaded[content]
            else
                writer::writeln "%s[%q] = function(...)"::format @_package_preload_name!, name
                writer::endwrap ->
                    if @options.compat_arg != false and content::match "%.%.%."
                        writer::writeln "local arg = __luapack_arg__"
                    writer::writelines content
                already_loaded[content] = package_name
            if @options.clear_loaded != false
                writer::writeln "%s[%q] = nil"::format @_package_loaded_name!, name
        
        if @loaded[@_entry_name!]?
            -- some C functions may return "fake" nil which behave differently
            -- returning it crashes some environments
            -- assigning it to a variable fixes the issue
            --  TODO: do we need the `do` block?
            writer::writeln "do"
            writer::endwrap ->
                writer::writeln 'local _result = %s[%q](...)'::format @_package_preload_name!, @_entry_name!
                writer::writeln "return _result"
        writer::str!

-- cli
cli = (arguments) ->
    options = {}
    for arg in *arguments
        continue if "-" != arg::sub 1, 1
        operator, name = arg::match "^-(%w+)-([%w-]+)$"
        if operator?
          error "invalid operator" if operator != "yes" and operator != "no"
          name = name::gsub "-", "_"
          options[name] = operator == "yes"
          continue

        name, value = arg::match "^-([%w-]+)=([%w-_.]+)$"
        if name?
          options[name::gsub "-", "_"] = value
          continue

    print "Using luapack #{__version__}"
    option_str = table.concat ["#{key}=#{if "string" == type value then value elseif value then "yes" else "no"}" for key, value in pairs options], ", "
    print "Options: #{option_str}" if #option_str > 0
    print!

    options.alias = alias_factory! if options.alias == true

    for filename in *arguments
        continue if "-" == filename::sub 1, 1
        print "Packing #{filename}"
        packer = Packer options

        if options.standalone
            local content
            do
              fd = io.open filename, "r"
              error "file not found: #{filename}" unless fd?
              with fd
                  content = ::read "*a"
                  ::close!
            packer::include name for name in content::gmatch "[^\n]+"
        else
            packer::pack filename

        packed = packer::export!
        outfile = options.outfile or filename::gsub "%.(%a+)$", ".packed.lua"
        print "Packed into #{outfile}"
        break if filename == outfile
        do
          fd = io.open outfile, "w"
          error "could not open file" unless fd?
          with fd
              ::write packed
              ::close!


check_cli = =>
    return if @n == 0
    return if @[2] == ":preload:" -- package.preload (luapacked)
    return unless arg? -- support for cli args

    -- check if they match
    for i = 1, @n
        return if arg[i] != @[i] -- dont match
    
    true


arguments = {...}
arguments.n = #arguments

cli arguments if check_cli arguments