improve register packages

3 files changed, 48 insertions, 127 deletions

diff --git a/xmake/modules/private/action/require/impl/install_packages.lua b/xmake/modules/private/action/require/impl/install_packages.lua
index 295c3bbbd..461131aa0 100644
--- a/xmake/modules/private/action/require/impl/install_packages.lua
+++ b/xmake/modules/private/action/require/impl/install_packages.lua
@@ -22,6 +22,7 @@
 import("core.base.option")
 import("core.base.hashset")
 import("core.base.scheduler")
+import("core.project.project")
 import("core.base.tty")
 import("private.async.runjobs")
 import("private.utils.progress")
@@ -29,6 +30,7 @@ import("actions.install", {alias = "action_install"})
 import("actions.download", {alias = "action_download"})
 import("net.fasturl")
 import("private.action.require.impl.package")
+import("private.action.require.impl.register_packages")
 
 -- sort packages urls
 function _sort_packages_urls(packages)
@@ -231,26 +233,31 @@ function _install_packages(packages_install, packages_download)
                 -- download this package first
                 local downloaded = true
                 if packages_download[tostring(instance)] then
-                    packages_downloading[index] =instance 
+                    packages_downloading[index] = instance
                     downloaded = action_download(instance)
                     packages_downloading[index] = nil
                 end
 
                 -- install this package
-                packages_installing[index] =instance 
+                packages_installing[index] = instance
                 if downloaded then
                     action_install(instance)
                 end
-                packages_installing[index] = nil
+
+                -- register it to local cache if it is root required package
+                if not instance:parents() then
+                    register_packages(instance)
+                end
 
                 -- mark this group as 'installed' or 'failed'
                 if group then
                     packages_in_group[group] = instance:exists() and 1 or -1
                 end
 
-                -- enable parallelize
+                -- next
                 parallelize = true
                 installing_count = installing_count - 1
+                packages_installing[index] = nil
             end
         end
         packages_installing[index] = nil
@@ -321,6 +328,25 @@ function _install_packages(packages_install, packages_download)
     end})
 end
 
+-- only enable the first package in same group and root packages
+function _disable_other_packages_in_group(packages)
+    local registered_in_group = {}
+    for _, instance in ipairs(packages) do
+        local group = instance:group()
+        if not instance:parents() and group then
+            local required_package = project.required_package(instance:alias() or instance:name())
+            if required_package then
+                if not registered_in_group[group] and required_package:enabled() then
+                    registered_in_group[group] = true
+                elseif required_package:enabled() then
+                    required_package:enable(false)
+                    required_package:save()
+                end
+            end
+        end
+    end
+end
+
 -- install packages
 function main(requires, opt)
 
@@ -348,7 +374,7 @@ function main(requires, opt)
         if not instance:exists() then
             if instance:supported() then
                 if #instance:urls() > 0 then
-                    packages_download[tostring(instance)] =instance 
+                    packages_download[tostring(instance)] = instance
                 end
                 table.insert(packages_install, instance)
             elseif not instance:optional() then
@@ -388,6 +414,12 @@ function main(requires, opt)
 
     -- install all required packages from repositories
     _install_packages(packages_install, packages_download)
+
+    -- register all required root packages to local cache
+    register_packages(packages)
+
+    -- disable other packages in same group
+    _disable_other_packages_in_group(packages)
     return packages
 end
 
diff --git a/xmake/modules/private/action/require/impl/register_packages.lua b/xmake/modules/private/action/require/impl/register_packages.lua
index d0128cf16..6d28eba07 100644
--- a/xmake/modules/private/action/require/impl/register_packages.lua
+++ b/xmake/modules/private/action/require/impl/register_packages.lua
@@ -111,15 +111,21 @@ function _register_required_package(instance, required_package)
     required_package:save()
 end
 
--- register all required local packages
+-- register all required root packages to local cache
 function main(packages)
+    local registered_packages = _g.registered_packages or {}
     for _, instance in ipairs(packages) do
         if not instance:parents() then
-            local required_package = project.required_package(instance:alias() or instance:name())
-            if required_package then
-                _register_required_package(instance, required_package)
+            local required_packagename = instance:alias() or instance:name()
+            if not registered_packages[required_packagename] then
+                local required_package = project.required_package(required_packagename)
+                if required_package then
+                    _register_required_package(instance, required_package)
+                end
+                registered_packages[required_packagename] = instance
             end
         end
     end
+    _g.registered_packages = registered_packages
 end
 
diff --git a/xmake/modules/private/action/require/install.lua b/xmake/modules/private/action/require/install.lua
index ae65772e6..5750f4b0e 100644
--- a/xmake/modules/private/action/require/install.lua
+++ b/xmake/modules/private/action/require/install.lua
@@ -21,126 +21,12 @@
 -- imports
 import("core.base.option")
 import("core.base.task")
-import("core.project.project")
 import("lib.detect.find_tool")
 import("private.action.require.impl.repository")
 import("private.action.require.impl.environment")
 import("private.action.require.impl.install_packages")
 import("private.action.require.impl.utils.get_requires")
 
--- register required package environments
--- envs: bin path for *.dll, program ..
-function _register_required_package_envs(instance, envs)
-    for name, values in pairs(instance:envs()) do
-        if name == "PATH" or name == "LD_LIBRARY_PATH" or name == "DYLD_LIBRARY_PATH" then
-            for _, value in ipairs(values) do
-                envs[name] = envs[name] or {}
-                if path.is_absolute(value) then
-                    table.insert(envs[name], value)
-                else
-                    table.insert(envs[name], path.join(instance:installdir(), value))
-                end
-            end
-        else
-            envs[name] = envs[name] or {}
-            table.join2(envs[name], values)
-        end
-    end
-end
-
--- register required package libraries
--- libs: includedirs, links, linkdirs ...
-function _register_required_package_libs(instance, required_package, is_deps)
-    if instance:is_library() then
-        local fetchinfo = instance:fetch()
-        if fetchinfo then
-            fetchinfo.name    = nil
-            if is_deps then
-                -- we need only reserve license for root package
-                --
-                -- @note the license compatibility between the root package and
-                -- its dependent packages is guaranteed by the root package itself
-                --
-                fetchinfo.license = nil
-
-                -- we need only some infos for root package
-                fetchinfo.version = nil
-                fetchinfo.static  = nil
-                fetchinfo.shared  = nil
-            end
-            required_package:add(fetchinfo)
-        end
-    end
-end
-
--- register the base info of required package
-function _register_required_package_base(instance, required_package)
-    if not instance:isSys() and not instance:is3rd() then
-        required_package:set("__installdir", instance:installdir())
-    end
-end
-
--- register the required local package
-function _register_required_package(instance, required_package)
-
-    -- disable it if this package is optional and missing
-    if _g.optional_missing[instance:name()] then
-        required_package:enable(false)
-    else
-        -- clear require info first
-        required_package:clear()
-
-        -- add packages info with all dependencies
-        local envs = {}
-        _register_required_package_base(instance, required_package)
-        _register_required_package_libs(instance, required_package)
-        _register_required_package_envs(instance, envs)
-        local orderdeps = instance:orderdeps()
-        if orderdeps then
-            local total = #orderdeps
-            for idx, _ in ipairs(orderdeps) do
-                local dep = orderdeps[total + 1 - idx]
-                if dep then
-                    _register_required_package_libs(dep, required_package, true)
-                    _register_required_package_envs(dep, envs)
-                end
-            end
-        end
-        if #table.keys(envs) > 0 then
-            required_package:add({envs = envs})
-        end
-
-        -- enable this require info
-        required_package:enable(true)
-    end
-
-    -- save this require info and flush the whole cache file
-    required_package:save()
-end
-
--- register all required local packages
-function _register_required_packages(packages)
-    local registered_in_group = {}
-    for _, instance in ipairs(packages) do
-
-        -- only register the first package in same group and root packages
-        local group = instance:group()
-        if not instance:parents() and (not group or not registered_in_group[group]) then
-
-            -- register required package
-            local required_package = project.required_package(instance:alias() or instance:name())
-            if required_package then
-                _register_required_package(instance, required_package)
-            end
-
-            -- mark as registered in group
-            if group then
-                registered_in_group[group] = true
-            end
-        end
-    end
-end
-
 -- check missing packages
 function _check_missing_packages(packages)
 
@@ -148,7 +34,7 @@ function _check_missing_packages(packages)
     local packages_missing = {}
     local optional_missing = {}
     for _, instance in ipairs(packages) do
-        if not instance:exists() and (#instance:urls() > 0 or instance:isSys()) then
+        if not instance:exists() then
             if instance:optional() then
                 optional_missing[instance:name()] = instance
             else
@@ -200,9 +86,6 @@ function main(requires_raw)
 
         -- check missing packages
         _check_missing_packages(packages)
-
-        -- register all required local packages
-        _register_required_packages(packages)
     end
     environment.leave()
 end