writer

6 files changed, 108 insertions, 38 deletions

diff --git a/src/luarocks/core/cfg.d.tl b/src/luarocks/core/cfg.d.tl
index 9c4d0e3f..2c32569a 100644
--- a/src/luarocks/core/cfg.d.tl
+++ b/src/luarocks/core/cfg.d.tl
@@ -77,6 +77,8 @@ local record cfg
    hooks_enabled: boolean
    wrap_bin_scripts: boolean
    wrapper_suffix: string
+   -- writer
+   no_manifest: boolean
 end
 
 return cfg
\ No newline at end of file
diff --git a/src/luarocks/fs.d.tl b/src/luarocks/fs.d.tl
index 4868889c..73848524 100644
--- a/src/luarocks/fs.d.tl
+++ b/src/luarocks/fs.d.tl
@@ -56,6 +56,9 @@ local record fs
    is_lua: function(string): boolean
    copy_binary: function(string, string): boolean, string
    move: function(string, string, string): boolean, string
+   -- writer
+   replace_file: function(string, string): boolean, string
+   get_md5: function(string): string
 end
 
 return fs
diff --git a/src/luarocks/manif/writer.tl b/src/luarocks/manif/writer.tl
index 0461b230..2b303fd5 100644
--- a/src/luarocks/manif/writer.tl
+++ b/src/luarocks/manif/writer.tl
@@ -22,6 +22,12 @@ local type Manifest = m.Manifest
 local type r = require("luarocks.core.types.rockspec")
 local type Rockspec = r.Rockspec
 
+local type res = require("luarocks.core.types.result")
+local type Result = res.Result
+
+local type p = require("luarocks.core.types.persist")
+local type PersistableTable = p.PersistableTable
+
 --- Update storage table to account for items provided by a package.
 -- @param storage table: a table storing items in the following format:
 -- keys are item names and values are arrays of packages providing each item,
@@ -204,16 +210,14 @@ end
 -- @param manifest table: A manifest table (must contain repository, modules, commands tables).
 -- It will be altered to include the search results.
 -- @return boolean or (nil, string): true in case of success, or nil followed by an error message.
-local function store_results(results, manifest)
-   assert(type(results) == "table")
-   assert(type(manifest) == "table")
+local function store_results(results: {string: {string: {Result}}}, manifest: Manifest): boolean, string
 
    for name, versions in pairs(results) do
       local pkgtable = manifest.repository[name] or {}
       for version, entries in pairs(versions) do
          local versiontable = {}
          for _, entry in ipairs(entries) do
-            local entrytable = {}
+            local entrytable: Manifest = {}
             entrytable.arch = entry.arch
             if entry.arch == "installed" then
                local rock_manifest, err = manif.load_rock_manifest(name, version)
@@ -235,16 +239,46 @@ local function store_results(results, manifest)
    return true
 end
 
+-- and here what would `entrytable` be, since it can either be a `Manifest` or ...
+-- ```
+-- local function store_results(results: {string: {string: {Result}}}, manifest: Manifest): boolean
+
+--    for name, versions in pairs(results) do
+--       local pkgtable = manifest.repository[name] or {}
+--       for version, entries in pairs(versions) do
+--          local versiontable = {}
+--          for _, entry in ipairs(entries) do
+--             local entrytable: Manifest = {}
+--             entrytable.arch = entry.arch
+--             if entry.arch == "installed" then
+--                local rock_manifest, err = manif.load_rock_manifest(name, version)
+--                if not rock_manifest then return nil, err end
+
+--                entrytable.modules = repos.package_modules(name, version)
+--                store_package_items(manifest.modules, name, version, entrytable.modules)
+--                entrytable.commands = repos.package_commands(name, version)
+--                store_package_items(manifest.commands, name, version, entrytable.commands)
+--             end
+--             table.insert(versiontable, entrytable)
+--          end
+--          pkgtable[version] = versiontable
+--       end
+--       manifest.repository[name] = pkgtable
+--    end
+--    sort_package_matching_table(manifest.modules)
+--    sort_package_matching_table(manifest.commands)
+--    return true
+-- end
+-- ```
+
 --- Commit a table to disk in given local path.
 -- @param where string: The directory where the table should be saved.
 -- @param name string: The filename.
 -- @param tbl table: The table to be saved.
 -- @return boolean or (nil, string): true if successful, or nil and a
 -- message in case of errors.
-local function save_table(where, name, tbl)
-   assert(type(where) == "string")
-   assert(type(name) == "string" and not name:match("/"))
-   assert(type(tbl) == "table")
+local function save_table(where: string, name: string, tbl: PersistableTable): boolean, string
+   assert(not name:match("/"))
 
    local filename = dir.path(where, name)
    local ok, err = persist.save_from_table(filename..".tmp", tbl)
@@ -254,16 +288,17 @@ local function save_table(where, name, tbl)
    return ok, err
 end
 
-function writer.make_rock_manifest(name, version)
+function writer.make_rock_manifest(name: string, version: string): boolean, string
    local install_dir = path.install_dir(name, version)
-   local tree = {}
+   local tree: {string: {string}} = {}
    for _, file in ipairs(fs.find(install_dir)) do
       local full_path = dir.path(install_dir, file)
       local walk = tree
-      local last
-      local last_name
+      local last: {string : {string}}
+      local last_name: string
+      local next: {string}
       for filename in file:gmatch("[^\\/]+") do
-         local next = walk[filename]
+         next = walk[filename]
          if not next then
             next = {}
             walk[filename] = next
@@ -286,16 +321,50 @@ function writer.make_rock_manifest(name, version)
    return true
 end
 
+-- in this code, what would next and walk be, since we have `walk[filename] = next`,  but also `walk = next`
+-- ```
+-- function writer.make_rock_manifest(name: string, version: string): boolean, string
+--    local install_dir = path.install_dir(name, version)
+--    local tree: {string: {string}} = {}
+--    for _, file in ipairs(fs.find(install_dir)) do
+--       local full_path = dir.path(install_dir, file)
+--       local walk = tree
+--       local last: {string : {string}}
+--       local last_name: string
+--       local next: {string}
+--       for filename in file:gmatch("[^\\/]+") do
+--          next = walk[filename]
+--          if not next then
+--             next = {}
+--             walk[filename] = next
+--          end
+--          last = walk
+--          last_name = filename
+--          walk = next
+--       end
+--       if fs.is_file(full_path) then
+--          local sum, err = fs.get_md5(full_path)
+--          if not sum then
+--             return nil, "Failed producing checksum: "..tostring(err)
+--          end
+--          last[last_name] = sum
+--       end
+--    end
+--    local rock_manifest = { rock_manifest=tree }
+--    manif.rock_manifest_cache[name.."/"..version] = rock_manifest
+--    save_table(install_dir, "rock_manifest", rock_manifest )
+--    return true
+-- end
+-- ```
+
 -- Writes a 'rock_namespace' file in a locally installed rock directory.
 -- @param name string: the rock name, without a namespace
 -- @param version string: the rock version
 -- @param namespace string?: the namespace
 -- @return true if successful (or unnecessary, if there is no namespace),
 -- or nil and an error message.
-function writer.make_namespace_file(name, version, namespace)
-   assert(type(name) == "string" and not name:match("/"))
-   assert(type(version) == "string")
-   assert(type(namespace) == "string" or not namespace)
+function writer.make_namespace_file(name: string, version: string, namespace?: string): boolean, string
+   assert(not name:match("/"))
    if not namespace then
       return true
    end
@@ -321,9 +390,7 @@ end
 -- @param remote boolean: 'true' if making a manifest for a rocks server.
 -- @return boolean or (nil, string): True if manifest was generated,
 -- or nil and an error message.
-function writer.make_manifest(repo, deps_mode, remote)
-   assert(type(repo) == "string")
-   assert(type(deps_mode) == "string")
+function writer.make_manifest(repo: string, deps_mode: string, remote?: boolean): boolean, string
 
    if deps_mode == "none" then deps_mode = cfg.deps_mode end
 
@@ -344,10 +411,10 @@ function writer.make_manifest(repo, deps_mode, remote)
       local cache = {}
       for luaver in util.lua_versions() do
          local vmanifest = { repository = {}, modules = {}, commands = {} }
-         local ok, err = store_results(results, vmanifest)
+         ok, err = store_results(results, vmanifest)
          filter_by_lua_version(vmanifest, luaver, repo, cache)
          if not cfg.no_manifest then
-            save_table(repo, "manifest-"..luaver, vmanifest)
+            save_table(repo, "manifest-"..luaver, vmanifest as PersistableTable)
          end
       end
    else
@@ -358,7 +425,7 @@ function writer.make_manifest(repo, deps_mode, remote)
       -- We want to have cache updated; but exit before save_table is called
       return true
    end
-   return save_table(repo, "manifest", manifest)
+   return save_table(repo, "manifest", manifest as PersistableTable)
 end
 
 --- Update manifest file for a local repository
@@ -372,11 +439,9 @@ end
 -- "none" for using the default dependency mode from the configuration.
 -- @return boolean or (nil, string): True if manifest was updated successfully,
 -- or nil and an error message.
-function writer.add_to_manifest(name, version, repo, deps_mode)
-   assert(type(name) == "string" and not name:match("/"))
-   assert(type(version) == "string")
+function writer.add_to_manifest(name: string, version: string, repo: string, deps_mode: string): boolean, string  
+   assert(not name:match("/"))
    local rocks_dir = path.rocks_dir(repo or cfg.root_dir)
-   assert(type(deps_mode) == "string")
 
    if deps_mode == "none" then deps_mode = cfg.deps_mode end
 
@@ -391,7 +456,8 @@ function writer.add_to_manifest(name, version, repo, deps_mode)
 
    local results = {[name] = {[version] = {{arch = "installed", repo = rocks_dir}}}}
 
-   local ok, err = store_results(results, manifest)
+   local ok: boolean
+   ok, err = store_results(results, manifest) --!
    if not ok then return nil, err end
 
    update_dependencies(manifest, deps_mode)
@@ -399,7 +465,7 @@ function writer.add_to_manifest(name, version, repo, deps_mode)
    if cfg.no_manifest then
       return true
    end
-   return save_table(rocks_dir, "manifest", manifest)
+   return save_table(rocks_dir, "manifest", manifest as PersistableTable)
 end
 
 --- Update manifest file for a local repository
@@ -413,11 +479,9 @@ end
 -- "none" for using the default dependency mode from the configuration.
 -- @return boolean or (nil, string): True if manifest was updated successfully,
 -- or nil and an error message.
-function writer.remove_from_manifest(name, version, repo, deps_mode)
-   assert(type(name) == "string" and not name:match("/"))
-   assert(type(version) == "string")
+function writer.remove_from_manifest(name: string, version: string, repo: string, deps_mode: string): boolean, string
+   assert(not name:match("/"))
    local rocks_dir = path.rocks_dir(repo or cfg.root_dir)
-   assert(type(deps_mode) == "string")
 
    if deps_mode == "none" then deps_mode = cfg.deps_mode end
 
@@ -441,7 +505,7 @@ function writer.remove_from_manifest(name, version, repo, deps_mode)
       return writer.make_manifest(rocks_dir, deps_mode)
    end
 
-   remove_package_items(manifest.modules, name, version, version_entry.modules)
+   remove_package_items(manifest.modules, name, version, version_entry.modules) --!
    remove_package_items(manifest.commands, name, version, version_entry.commands)
 
    package_entry[version] = nil
@@ -458,7 +522,7 @@ function writer.remove_from_manifest(name, version, repo, deps_mode)
    if cfg.no_manifest then
       return true
    end
-   return save_table(rocks_dir, "manifest", manifest)
+   return save_table(rocks_dir, "manifest", manifest as PersistableTable)
 end
 
 return writer
diff --git a/src/luarocks/path.tl b/src/luarocks/path.tl
index a75d7b83..ae5e5204 100644
--- a/src/luarocks/path.tl
+++ b/src/luarocks/path.tl
@@ -106,7 +106,7 @@ end
 -- @param tree string or nil: If given, specifies the local tree to use.
 -- @return string: The resulting path -- does not guarantee that
 -- the package (and by extension, the file) exists.
-function path.rock_namespace_file(name: string, version: string, tree: string | Tree): string
+function path.rock_namespace_file(name: string, version: string, tree?: string | Tree): string
    assert(not name:match("/"))
    return dir.path(path.rocks_dir(tree), name, version, "rock_namespace")
 end
diff --git a/src/luarocks/repo_writer.tl b/src/luarocks/repo_writer.tl
index 698af976..70a49f95 100644
--- a/src/luarocks/repo_writer.tl
+++ b/src/luarocks/repo_writer.tl
@@ -1,4 +1,5 @@
-local repo_writer = {}
+local record repo_writer
+end
 
 local fs = require("luarocks.fs")
 local path = require("luarocks.path")
diff --git a/src/luarocks/search.tl b/src/luarocks/search.tl
index caf01221..fdeebcd8 100644
--- a/src/luarocks/search.tl
+++ b/src/luarocks/search.tl
@@ -66,7 +66,7 @@ end
 -- values are tables matching version strings to arrays of
 -- tables with fields "arch" and "repo".
 -- If a table was given in the "result_tree" parameter, that is the result value.
-function search.disk_search(repo: string, query: Query, result_tree: {string: {string: {Result}}}):  {string: {string: {Result}}}
+function search.disk_search(repo: string, query: Query, result_tree?: {string: {string: {Result}}}):  {string: {string: {Result}}}
 
    local fs = require("luarocks.fs")