Merge pull request #4062 from memsharded/feature/load_name_version

loading name-version for export

conans/client/cmd/download.py

@@ -1,5 +1,3 @@
-import os
-
 from conans.client.output import ScopedOutput
 from conans.client.source import complete_recipe_sources
 from conans.errors import NotFoundException
@@ -23,34 +21,25 @@ def download(reference, package_ids, remote_name, recipe, registry, remote_manag
     conan_file_path = client_cache.conanfile(reference)
     conanfile = loader.load_class(conan_file_path)
 
-    if not recipe:
+    if not recipe:  # Not only the recipe
         # Download the sources too, don't be lazy
-        complete_recipe_sources(remote_manager, client_cache, registry,
-                                conanfile, reference)
-
-        if package_ids:
-            _download_binaries(reference, package_ids, client_cache, remote_manager,
-                               remote, output, recorder, loader)
-        else:
-            output.info("Getting the complete package list "
-                        "from '%s'..." % str(reference))
+        complete_recipe_sources(remote_manager, client_cache, registry, conanfile, reference)
+
+        if not package_ids:  # User didnt specify a specific package binary
+            output.info("Getting the complete package list from '%s'..." % str(reference))
             packages_props = remote_manager.search_packages(remote, reference, None)
-            if not packages_props:
-                output = ScopedOutput(str(reference), out)
+            package_ids = list(packages_props.keys())
+            if not package_ids:
                 output.warn("No remote binary packages found in remote")
-            else:
-                _download_binaries(reference, list(packages_props.keys()), client_cache,
-                                   remote_manager, remote, output, recorder, loader)
+
+        _download_binaries(conanfile, reference, package_ids, client_cache, remote_manager,
+                           remote, output, recorder)
     hook_manager.execute("post_download", conanfile_path=conan_file_path, reference=reference,
                          remote=remote)
 
 
-def _download_binaries(reference, package_ids, client_cache, remote_manager, remote, output,
-                       recorder, loader):
-    conanfile_path = client_cache.conanfile(reference)
-    if not os.path.exists(conanfile_path):
-        raise Exception("Download recipe first")
-    conanfile = loader.load_class(conanfile_path)
+def _download_binaries(conanfile, reference, package_ids, client_cache, remote_manager, remote,
+                       output, recorder):
     short_paths = conanfile.short_paths
 
     for package_id in package_ids:

conans/client/command.py

@@ -1463,7 +1463,11 @@ def get_reference_fields(arg_reference):
 
     try:
         name_version, user_channel = arg_reference.split("@")
-        name, version = name_version.split("/")
+        name_version = name_version.split("/")
+        try:
+            name, version = name_version
+        except ValueError:
+            name, version = None, name_version[0]
         user, channel = user_channel.split("/")
     except ValueError:
         name, version = None, None

conans/client/conan_api.py

@@ -353,8 +353,9 @@ def create(self, conanfile_path, name=None, version=None, user=None, channel=Non
             recorder = ActionRecorder()
             conanfile_path = _get_conanfile_path(conanfile_path, cwd, py=True)
 
-            reference, conanfile = self._loader.load_export(conanfile_path, name, version, user,
-                                                            channel)
+            name, version = self._loader.load_name_version(conanfile_path, name, version)
+            reference = ConanFileReference(name, version, user, channel)
+            conanfile = self._loader.load_export(conanfile_path, reference)
 
             # Make sure keep_source is set for keep_build
             keep_source = keep_source or keep_build
@@ -426,8 +427,10 @@ def export_pkg(self, conanfile_path, name, channel, source_folder=None, build_fo
             else:
                 profile = read_conaninfo_profile(install_folder)
 
-            reference, conanfile = self._loader.load_export(conanfile_path, name, version, user,
-                                                            channel)
+            name, version = self._loader.load_name_version(conanfile_path, name, version)
+            reference = ConanFileReference(name, version, user, channel)
+            conanfile = self._loader.load_export(conanfile_path, reference)
+
             recorder.recipe_exported(reference)
             recorder.add_recipe_being_developed(reference)
             cmd_export(conanfile_path, conanfile, reference, False, self._user_io.out,
@@ -567,9 +570,9 @@ def config_install(self, item, verify_ssl, config_type=None, args=None):
             item = os.path.abspath(item)
 
         from conans.client.conf.config_installer import configuration_install
+        requester = self._remote_manager._auth_manager._rest_client.requester,  # FIXME: Look out!
         return configuration_install(item, self._client_cache, self._user_io.out, verify_ssl,
-                                     requester=self._remote_manager._auth_manager._rest_client.requester,  # FIXME: Look out!
-                                     config_type=config_type, args=args)
+                                     requester=requester, config_type=config_type, args=args)
 
     def _info_get_profile(self, reference, install_folder, profile_name, settings, options, env):
         cwd = get_cwd()
@@ -714,8 +717,9 @@ def imports_undo(self, manifest_path):
     @api_method
     def export(self, path, name, version, user, channel, keep_source=False, cwd=None):
         conanfile_path = _get_conanfile_path(path, cwd, py=True)
-        reference, conanfile = self._loader.load_export(conanfile_path, name, version, user,
-                                                        channel)
+        name, version = self._loader.load_name_version(conanfile_path, name, version)
+        reference = ConanFileReference(name, version, user, channel)
+        conanfile = self._loader.load_export(conanfile_path, reference)
         cmd_export(conanfile_path, conanfile, reference, keep_source, self._user_io.out,
                    self._client_cache, self._hook_manager)
 

conans/client/loader.py

@@ -46,30 +46,34 @@ def load_class(self, conanfile_path):
         _, conanfile = parse_conanfile(conanfile_path, self._python_requires)
         return conanfile
 
-    def load_export(self, conanfile_path, name, version, user, channel):
+    def load_name_version(self, conanfile_path, name, version):
         conanfile = self.load_class(conanfile_path)
-
-        # check name and version were specified
-        if not conanfile.name:
-            if name:
-                conanfile.name = name
+        # Do not inherit the name from python-requires
+        if "name" in conanfile.__dict__:
+            if name and name != conanfile.name:
+                raise ConanException("Package recipe exported with name %s!=%s"
+                                     % (name, conanfile.name))
             else:
-                raise ConanException("conanfile didn't specify name")
-        elif name and name != conanfile.name:
-            raise ConanException("Package recipe exported with name %s!=%s" % (name, conanfile.name))
-
-        if not conanfile.version:
-            if version:
-                conanfile.version = version
+                name = conanfile.name
+        elif not name:
+            raise ConanException("conanfile didn't specify name")
+
+        if "version" in conanfile.__dict__:
+            if version and version != conanfile.version:
+                raise ConanException("Package recipe exported with version %s!=%s"
+                                     % (version, conanfile.version))
             else:
-                raise ConanException("conanfile didn't specify version")
-        elif version and version != conanfile.version:
-            raise ConanException("Package recipe exported with version %s!=%s"
-                                 % (version, conanfile.version))
-
-        conan_ref = ConanFileReference(conanfile.name, conanfile.version, user, channel)
-        output = ScopedOutput(str(conan_ref), self._output)
-        return conan_ref, conanfile(output, self._runner, user, channel)
+                version = conanfile.version
+        elif not version:
+            raise ConanException("conanfile didn't specify version")
+        return name, version
+
+    def load_export(self, conanfile_path, ref):
+        conanfile = self.load_class(conanfile_path)
+        conanfile.name = ref.name
+        conanfile.version = ref.version
+        output = ScopedOutput(str(ref), self._output)
+        return conanfile(output, self._runner, ref.user, ref.channel)
 
     def load_basic(self, conanfile_path, output, reference=None):
         result = self.load_class(conanfile_path)

conans/test/command/create_test.py

@@ -1,10 +1,10 @@
+import os
+import unittest
 
+from conans.client import tools
 from conans.test.utils.tools import TestClient
-import unittest
-import os
-from parameterized.parameterized import parameterized
 from conans.util.files import load
-from conans.client import tools
+from parameterized.parameterized import parameterized
 
 
 class CreateTest(unittest.TestCase):
@@ -105,7 +105,8 @@ def test(self):
         self.assertIn("Pkg/0.1@lasote/testing package(): Copied 1 '.h' file: header.h", client.out)
         # keep build
         client.run("create . Pkg/0.1@lasote/testing --keep-build")
-        self.assertIn("Pkg/0.1@lasote/testing: Won't be built as specified by --keep-build", client.out)
+        self.assertIn("Pkg/0.1@lasote/testing: Won't be built as specified by --keep-build",
+                      client.out)
         self.assertNotIn("Pkg/0.1@lasote/testing: mysource!!", client.out)
         self.assertNotIn("Pkg/0.1@lasote/testing: mybuild!!", client.out)
         self.assertIn("Pkg/0.1@lasote/testing: mypackage!!", client.out)
@@ -116,7 +117,8 @@ def test(self):
         client.run("create . Pkg/0.1@lasote/testing --keep-build")
         # The source folder is removed, but not necessary, as it will reuse build
         self.assertNotIn("Pkg/0.1@lasote/testing: Removing 'source' folder", client.out)
-        self.assertIn("Pkg/0.1@lasote/testing: Won't be built as specified by --keep-build", client.out)
+        self.assertIn("Pkg/0.1@lasote/testing: Won't be built as specified by --keep-build",
+                      client.out)
         self.assertNotIn("Pkg/0.1@lasote/testing: mysource!!", client.out)
         self.assertNotIn("Pkg/0.1@lasote/testing: mybuild!!", client.out)
         self.assertIn("Pkg/0.1@lasote/testing: mypackage!!", client.out)
@@ -177,6 +179,40 @@ def system_requirements(self):
         self.assertIn("Invalid parameter 'lasote', specify the full reference or user/channel",
                       client.out)
 
+    def create_name_command_line_test(self):
+        client = TestClient()
+        client.save({"conanfile.py": """from conans import ConanFile
+class MyPkg(ConanFile):
+    name = "Pkg"
+    def source(self):
+        assert(self.version=="0.1")
+        assert(self.name=="Pkg")
+    def configure(self):
+        assert(self.version=="0.1")
+        assert(self.name=="Pkg")
+    def requirements(self):
+        assert(self.version=="0.1")
+        assert(self.name=="Pkg")
+    def build(self):
+        assert(self.version=="0.1")
+        assert(self.name=="Pkg")
+    def package(self):
+        assert(self.version=="0.1")
+        assert(self.name=="Pkg")
+    def package_info(self):
+        assert(self.version=="0.1")
+        assert(self.name=="Pkg")
+    def system_requirements(self):
+        assert(self.version=="0.1")
+        assert(self.name=="Pkg")
+        self.output.info("Running system requirements!!")
+"""})
+        client.run("create . 0.1@lasote/testing")
+        self.assertIn("Pkg/0.1@lasote/testing: Generating the package", client.out)
+        self.assertIn("Running system requirements!!", client.out)
+        client.run("search")
+        self.assertIn("Pkg/0.1@lasote/testing", client.out)
+
     def create_werror_test(self):
         client = TestClient()
         client.save({"conanfile.py": """from conans import ConanFile
@@ -382,8 +418,8 @@ def test(self):
 
         # Test that the build require is applyed to testing
         client.run("create . Lib/0.1@conan/stable --profile=./myprofile")
-        self.assertEqual(1, str(client.out).count("Lib/0.1@conan/stable: Applying build-requirement: "
-                                                  "Build1/0.1@conan/stable"))
+        self.assertEqual(1, str(client.out).count("Lib/0.1@conan/stable: Applying build-requirement:"
+                                                  " Build1/0.1@conan/stable"))
         self.assertIn("TESTING!!", client.user_io.out)
 
     def build_policy_test(self):
@@ -435,18 +471,21 @@ def test(self):
         default_build_dir = os.path.join(client.current_folder, "test_package", "build")
 
         # Test the default behavior.
-        client.save({"conanfile.py": conanfile, "test_package/conanfile.py": test_conanfile}, clean_first=True)
+        client.save({"conanfile.py": conanfile, "test_package/conanfile.py": test_conanfile},
+                    clean_first=True)
         client.run("create . lasote/stable")
         self.assertTrue(os.path.exists(default_build_dir))
 
         # Test if the specified build folder is respected.
-        client.save({"conanfile.py": conanfile, "test_package/conanfile.py": test_conanfile}, clean_first=True)
+        client.save({"conanfile.py": conanfile, "test_package/conanfile.py": test_conanfile},
+                    clean_first=True)
         client.run("create -tbf=build_folder . lasote/stable")
         self.assertTrue(os.path.exists(os.path.join(client.current_folder, "build_folder")))
         self.assertFalse(os.path.exists(default_build_dir))
 
         # Test if using a temporary test folder can be enabled via the environment variable.
-        client.save({"conanfile.py": conanfile, "test_package/conanfile.py": test_conanfile}, clean_first=True)
+        client.save({"conanfile.py": conanfile, "test_package/conanfile.py": test_conanfile},
+                    clean_first=True)
         with tools.environment_append({"CONAN_TEMP_TEST_FOLDER": "True"}):
             client.run("create . lasote/stable")
         self.assertFalse(os.path.exists(default_build_dir))