Decreasing required memory (#976)

* Decreasing required memory

library/control/src/modules/ProductProfile.rb

@@ -6,6 +6,7 @@
 # $Id$
 require "yast"
 require "shellwords"
+require "y2packager/resolvable"
 
 module Yast
   class ProductProfileClass < Module
@@ -82,11 +83,11 @@ def IsCompliant(product_id)
       end
 
       # iterate all (or given) products and get the info about them
-      Builtins.foreach(Pkg.ResolvableProperties("", :product, "")) do |product|
-        src_id = Ops.get_integer(product, "source", -1)
-        name = Ops.get_string(product, "name", "")
+      Y2Packager::Resolvable.find(kind: :product).each do |product|
+        src_id = product.source
+        name = product.name
         if product_id.nil? &&
-            Ops.get_symbol(product, "status", :none) != :selected
+            product.status != :selected
           next
         end
         next if !product_id.nil? && src_id != product_id
@@ -109,16 +110,16 @@ def IsCompliant(product_id)
         end
         # generate product map:
         version_release = Builtins.splitstring(
-          Ops.get_string(product, "version", ""),
+          product.version,
           "-"
         )
         products = Builtins.add(
           products,
-          "arch"    => Ops.get_string(product, "arch", ""),
+          "arch"    => product.arch,
           "name"    => name,
           "version" => Ops.get(version_release, 0, ""),
           "release" => Ops.get(version_release, 1, ""),
-          "vendor"  => Ops.get_string(product, "vendor", "")
+          "vendor"  => product.vendor
         )
         sigkeys = Convert.convert(
           Builtins.union(sigkeys, GetSigKeysForProduct(src_id)),

library/control/src/modules/WorkflowManager.rb

@@ -37,6 +37,7 @@
 
 require "packages/package_downloader"
 require "packages/package_extractor"
+require "y2packager/resolvable"
 
 module Yast
   class WorkflowManagerClass < Module
@@ -414,12 +415,12 @@ def control_file(source)
       package = case source
       when ::Integer
         product = find_product(source)
-        return nil unless product && product["product_package"]
+        return nil unless product&.product_package
 
-        product_package = product["product_package"]
+        product_package = product.product_package
 
         # the dependencies are bound to the product's -release package
-        release_package = Pkg.ResolvableDependencies(product_package, :package, "").first
+        release_package = Y2Packager::Resolvable.find(kind: :package, name: product_package).first
 
         # find the package name with installer update in its Provide dependencies
         control_file_package = find_control_package(release_package)
@@ -1609,14 +1610,14 @@ def merge_modules_extensions(packages)
     # @return [Hash,nil] pkg-bindings product hash or nil if not found
     def find_product(repo_id)
       # identify the product
-      products = Pkg.ResolvableDependencies("", :product, "")
+      products = Y2Packager::Resolvable.find(kind: :product)
       return nil unless products
 
-      products.select! { |p| p["source"] == repo_id }
+      products.select! { |p| p.source == repo_id }
 
       if products.size > 1
         log.warn("More than one product found in the repository: #{products}")
-        log.warn("Using the first one: #{products.first}")
+        log.warn("Using the first one: #{products.first.name}")
       end
 
       products.first
@@ -1625,11 +1626,12 @@ def find_product(repo_id)
     # Find the extension package name for the specified release package.
     # The extension package is defined by the "installerextension()"
     # RPM "Provides" dependency.
+    # @param  [Y2Packager::Resolvable] release package
     # @return [String,nil] a package name or nil if not found
     def find_control_package(release_package)
-      return nil unless release_package && release_package["deps"]
+      return nil unless release_package&.deps
 
-      release_package["deps"].each do |dep|
+      release_package.deps.each do |dep|
         provide = dep["provides"]
         next unless provide
 
@@ -1648,23 +1650,23 @@ def find_control_package(release_package)
     # @return [Fixnum,nil] repository ID or nil if not found
     def package_repository(package_name)
       # Identify the installation repository with the package
-      pkgs = Pkg.ResolvableProperties(package_name, :package, "")
+      pkgs = Y2Packager::Resolvable.find(kind: :package, name: package_name)
 
       if pkgs.empty?
         log.warn("The installer extension package #{package_name} was not found")
         return nil
       end
 
       latest_package = pkgs.reduce(nil) do |a, p|
-        (!a || (Pkg.CompareVersions(a["version"], p["version"]) < 0)) ? p : a
+        (!a || (Pkg.CompareVersions(a.version, p.version) < 0)) ? p : a
       end
 
       if pkgs.size > 1
         log.warn("More than one control package found: #{pkgs}")
         log.info("Using the latest package: #{latest_package}")
       end
 
-      latest_package["source"]
+      latest_package.source
     end
 
     # Download and extract a package from a repository.

library/control/test/workflow_manager_test.rb

@@ -286,19 +286,25 @@
     # setup fake products and their packages
     let(:repo_id) { 42 }
     let(:product_package) { "foo-release" }
-    let(:product) { { "name" => "foo", "source" => repo_id, "product_package" => product_package } }
+    let(:product) do
+      Y2Packager::Resolvable.new("kind" => :product, "name" => "foo", "source" => repo_id,
+      "version" => "1.0", "arch" => "x86_64", "product_package" => product_package)
+    end
     let(:ext_package) { "foo-installation" }
-    let(:extension) { { "name" => ext_package, "source" => repo_id } }
+    let(:extension) do
+      Y2Packager::Resolvable.new("kind" => :package, "name" => ext_package, "source" => repo_id,
+        "version" => "1.0", "arch" => "x86_64", "deps" => [])
+    end
     let(:release) do
-      { "name" => product_package, "source" => repo_id,
-      "deps" => ["provides" => "installerextension(#{ext_package})"] }
+      Y2Packager::Resolvable.new("name" => product_package, "source" => repo_id, "version" => "1.0", "arch" => "x86_64",
+      "kind" => :package, "deps" => ["provides" => "installerextension(#{ext_package})"])
     end
 
     before do
       # generic mocks, can be are overriden in the tests
-      allow(Yast::Pkg).to receive(:ResolvableDependencies).with("", :product, "").and_return([product])
-      allow(Yast::Pkg).to receive(:ResolvableDependencies).with(product_package, :package, "").and_return([release])
-      allow(Yast::Pkg).to receive(:ResolvableProperties).with(ext_package, :package, "").and_return([extension])
+      allow(Y2Packager::Resolvable).to receive(:find).with(kind: :product).and_return([product])
+      allow(Y2Packager::Resolvable).to receive(:find).with(name: product_package, kind: :package).and_return([release])
+      allow(Y2Packager::Resolvable).to receive(:find).with(name: ext_package, kind: :package).and_return([extension])
       allow_any_instance_of(Packages::PackageDownloader).to receive(:download)
       allow_any_instance_of(Packages::PackageExtractor).to receive(:extract)
       # allow using it at other places
@@ -307,42 +313,46 @@
 
     context "when repository id is passed" do
       it "returns nil if the repository does not provide any product" do
-        expect(Yast::Pkg).to receive(:ResolvableDependencies).with("", :product, "").and_return([])
+        expect(Y2Packager::Resolvable).to receive(:find).with(kind: :product).and_return([])
         expect(subject.control_file(repo_id)).to be nil
       end
 
       it "returns nil if the product does not refer to a release package" do
-        product = { "name" => "foo", "source" => repo_id }
-        expect(Yast::Pkg).to receive(:ResolvableDependencies).with("", :product, "").and_return([product])
+        product = Y2Packager::Resolvable.new("kind" => :product, "name" => "foo", "source" => repo_id,
+          "version" => "1.0", "arch" => "x86_64", "product_package" => product_package)
+        expect(Y2Packager::Resolvable).to receive(:find).with(kind: :product).and_return([product])
         expect(subject.control_file(repo_id)).to be nil
       end
 
       it "returns nil if the product belongs to a different repository" do
-        product = { "name" => "foo", "source" => repo_id + 1 }
-        expect(Yast::Pkg).to receive(:ResolvableDependencies).with("", :product, "").and_return([product])
+        product = Y2Packager::Resolvable.new("kind" => :product, "name" => "foo", "source" => repo_id + 1,
+          "version" => "1.0", "arch" => "x86_64", "product_package" => product_package)
+        expect(Y2Packager::Resolvable).to receive(:find).with(kind: :product).and_return([product])
         expect(subject.control_file(repo_id)).to be nil
       end
 
       it "returns nil if the release package cannot be found" do
-        expect(Yast::Pkg).to receive(:ResolvableDependencies).with(product_package, :package, "").and_return([])
+        expect(Y2Packager::Resolvable).to receive(:find).with(name: product_package, kind: :package).and_return([])
         expect(subject.control_file(repo_id)).to be nil
       end
 
       it "returns nil if the release package does not have any dependencies" do
-        release = { "name" => "foo", "source" => repo_id }
-        expect(Yast::Pkg).to receive(:ResolvableDependencies).with(product_package, :package, "").and_return([release])
+        release = Y2Packager::Resolvable.new("kind" => :package, "name" => "foo", "source" => repo_id,
+          "version" => "1.0", "arch" => "x86_64", "deps" => [])
+        expect(Y2Packager::Resolvable).to receive(:find).with(name: product_package, kind: :package).and_return([release])
         expect(subject.control_file(repo_id)).to be nil
       end
 
       it "returns nil if the release package does not have any installerextension() provides" do
-        release = { "name" => "foo", "source" => repo_id, "deps" => ["provides" => "foo"] }
-        expect(Yast::Pkg).to receive(:ResolvableDependencies).with(product_package, :package, "").and_return([release])
+        release = Y2Packager::Resolvable.new("kind" => :package, "name" => "foo", "source" => repo_id,
+          "version" => "1.0", "arch" => "x86_64", "deps" => ["provides" => "foo"])
+        expect(Y2Packager::Resolvable).to receive(:find).with(name: product_package, kind: :package).and_return([release])
         expect(subject.control_file(repo_id)).to be nil
       end
     end
 
     it "returns nil if the installer extension package is not found" do
-      expect(Yast::Pkg).to receive(:ResolvableProperties).with(ext_package, :package, "").and_return([])
+      expect(Y2Packager::Resolvable).to receive(:find).with(name: ext_package, kind: :package).and_return([])
       expect(subject.control_file(repo_id)).to be nil
     end
 

library/packages/src/lib/y2packager/licenses_fetchers/rpm.rb

@@ -11,6 +11,7 @@
 # ------------------------------------------------------------------------------
 
 require "y2packager/licenses_fetchers/archive"
+require "y2packager/resolvable"
 
 module Y2Packager
   module LicensesFetchers
@@ -66,11 +67,8 @@ def package
       def package_name
         return @package_name if @package_name
 
-        package_properties = Yast::Pkg.ResolvableProperties(product_name, :product, "")
-        package_properties = package_properties.find { |props| props.key?("product_package") }
-        package_properties ||= {}
-
-        @package_name = package_properties.fetch("product_package", nil)
+        package_property = Y2Packager::Resolvable.find(kind: :product, name: product_name).first
+        @package_name = package_property.product_package if package_property
       end
     end
   end

library/packages/src/lib/y2packager/product.rb

@@ -14,6 +14,7 @@
 require "y2packager/product_reader"
 require "y2packager/release_notes_reader"
 require "y2packager/product_license_mixin"
+require "y2packager/resolvable"
 
 module Y2Packager
   # Represent a product which is present in a repository. At this
@@ -64,6 +65,22 @@ def from_h(product)
         Y2Packager::Product.new(params)
       end
 
+      # Create a product from Y2Packager::Resolvable
+      # @param product [Y2Packager::Resolvable] product
+      # @param installation_package [String] installation package name
+      # @param displayorder [Integer] display order from the package provides
+      # @return [Y2Packager::Product] converted product
+      def from_resolvable(product, installation_package = "",
+        displayorder = nil)
+        Y2Packager::Product.new(
+          name: product.name, short_name: product.short_name,
+          display_name: product.display_name, version: product.version,
+          arch: product.arch, category: product.category,
+          vendor: product.vendor, order: displayorder,
+          installation_package: installation_package
+        )
+      end
+
       # Return all known available products
       #
       # @return [Array<Product>] Known available products
@@ -247,7 +264,7 @@ def release_notes(user_lang, format = :txt)
     def relnotes_url
       return nil unless resolvable_properties
 
-      url = resolvable_properties["relnotes_url"]
+      url = resolvable_properties.relnotes_url
       url.empty? ? nil : url
     end
 
@@ -260,8 +277,8 @@ def relnotes_url
     # @param statuses [Array<Symbol>] Status to compare with.
     # @return [Boolean] true if it is in the given status
     def status?(*statuses)
-      Yast::Pkg.ResolvableProperties(name, :product, "").any? do |res|
-        statuses.include?(res["status"])
+      Y2Packager::Resolvable.find(kind: :product, name: name).any? do |res|
+        statuses.include?(res.status)
       end
     end
 
@@ -273,9 +290,7 @@ def status?(*statuses)
     #
     # @return [Hash] properties
     def resolvable_properties
-      @resolvable_properties ||= Yast::Pkg.ResolvableProperties(name, :product, "").find do |data|
-        data["version"] == version
-      end
+      @resolvable_properties ||= Y2Packager::Resolvable.find(kind: :product, name: name, version: version).first
     end
   end
 end