Add more meaninful error when parsing conanfile reference (closes #3204)

conans/model/ref.py

@@ -1,5 +1,6 @@
 from collections import namedtuple
 import re
+from six import string_types
 from conans.errors import ConanException, InvalidNameException
 from conans.model.version import Version
 
@@ -8,37 +9,44 @@ class ConanName(object):
     _max_chars = 50
     _min_chars = 2
     _validation_pattern = re.compile("^[a-zA-Z0-9_][a-zA-Z0-9_\+\.-]{%s,%s}$"
-                                     % (_min_chars - 1, _max_chars))
+                                     % (_min_chars - 1, _max_chars - 1))
 
     @staticmethod
-    def invalid_name_message(name):
-        if len(name) > ConanName._max_chars:
-            message = ("'%s' is too long. Valid names must contain at most %s characters."
-                       % (name, ConanName._max_chars))
-        elif len(name) < ConanName._min_chars:
-            message = ("'%s' is too short. Valid names must contain at least %s characters."
-                       % (name, ConanName._min_chars))
+    def invalid_name_message(value, message=None):
+        message = message or "'{value}' {reason}"
+        if len(value) > ConanName._max_chars:
+            reason = "is too long. Valid names must contain at most %s characters."\
+                     % ConanName._max_chars
+        elif len(value) < ConanName._min_chars:
+            reason = "is too short. Valid names must contain at least %s characters."\
+                     % ConanName._min_chars
         else:
-            message = ("'%s' is an invalid name. Valid names MUST begin with a "
-                       "letter or number, have between %s-%s chars, including "
-                       "letters, numbers, underscore, dot and dash"
-                       % (name, ConanName._min_chars, ConanName._max_chars))
-        raise InvalidNameException(message)
+            reason = ("is an invalid name. Valid names MUST begin with a "
+                      "letter, number or underscore, have between %s-%s chars, including "
+                      "letters, numbers, underscore, dot and dash"
+                      % (ConanName._min_chars, ConanName._max_chars))
+        raise InvalidNameException(message.format(value=value, reason=reason,
+                                                  type=type(value).__name__))
 
     @staticmethod
-    def validate_user(username):
-        if ConanName._validation_pattern.match(username) is None:
-            ConanName.invalid_name_message(username)
+    def validate_string(value, message=None):
+        """Check for string"""
+        if not isinstance(value, string_types):
+            message = message or "'{value}' (type {type}) {reason}"
+            raise InvalidNameException(message.format(value=value, reason="is not a string",
+                                                      type=type(value).__name__))
 
     @staticmethod
-    def validate_name(name, version=False):
+    def validate_name(name, version=False, message=None):
         """Check for name compliance with pattern rules"""
+        ConanName.validate_string(name, message=message)
         if name == "*":
             return
         if ConanName._validation_pattern.match(name) is None:
             if version and name.startswith("[") and name.endswith("]"):
+                # TODO: Check value between brackets
                 return
-            ConanName.invalid_name_message(name)
+            ConanName.invalid_name_message(name, message=message)
 
 
 class ConanFileReference(namedtuple("ConanFileReference", "name version user channel")):
@@ -52,16 +60,20 @@ class ConanFileReference(namedtuple("ConanFileReference", "name version user cha
     def __new__(cls, name, version, user, channel, revision=None):
         """Simple name creation.
         @param name:        string containing the desired name
-        @param validate:    checks for valid complex name. default True
+        @param version:     string containing the desired version
+        @param user:        string containing the user name
+        @param channel:     string containing the user channel
+        @param revision:    string containing the revision (optional)
         """
-        ConanName.validate_name(name)
-        ConanName.validate_name(version, True)
-        ConanName.validate_name(user)
-        ConanName.validate_name(channel)
+        message = "Value provided for {item}, '{{value}}' (type {{type}}), {{reason}}"
+        ConanName.validate_name(name, message=message.format(item="package name"))
+        ConanName.validate_name(version, True, message=message.format(item="package version"))
+        ConanName.validate_name(user, message=message.format(item="package user name"))
+        ConanName.validate_name(channel, message=message.format(item="package user"))
         version = Version(version)
         obj = super(cls, ConanFileReference).__new__(cls, name, version, user, channel)
         if revision:
-            ConanName.validate_name(revision)
+            ConanName.validate_name(revision, message=message.format(item="package revision"))
         obj.revision = revision
         return obj
 
@@ -123,7 +135,8 @@ def __new__(cls, conan, package_id):
         revision = None
         if "#" in package_id:
             package_id, revision = package_id.rsplit("#", 1)
-            ConanName.validate_name(revision)
+            message = "Value provided for package revision, '{value}' (type {type}) {reason}"
+            ConanName.validate_name(revision, message=message)
         obj = super(cls, PackageReference).__new__(cls, conan, package_id)
         obj.revision = revision
         return obj

conans/test/command/new_test.py

@@ -28,12 +28,12 @@ def new_error_test(self):
         client = TestClient()
         error = client.run('new A/1.3@myuser/testing', ignore_error=True)
         self.assertTrue(error)
-        self.assertIn("ERROR: 'A' is too short. Valid names must contain at least 2 characters.",
-                      client.user_io.out)
+        self.assertIn("ERROR: Value provided for package name, 'A' (type str), is too short. Valid "
+                      "names must contain at least 2 characters.", client.user_io.out)
         error = client.run('new A2/1.3@myuser/u', ignore_error=True)
         self.assertTrue(error)
-        self.assertIn("ERROR: 'u' is too short. Valid names must contain at least 2 characters.",
-                      client.user_io.out)
+        self.assertIn("ERROR: Value provided for package user, 'u' (type str), is too short. Valid "
+                      "names must contain at least 2 characters.", client.user_io.out)
 
     def new_dash_test(self):
         """ packages with dash

conans/test/model/ref_test.py

@@ -1,5 +1,5 @@
 import unittest
-from conans.model.ref import ConanFileReference
+from conans.model.ref import ConanFileReference, ConanName, InvalidNameException
 from conans.errors import ConanException
 
 
@@ -42,3 +42,55 @@ def errors_test(self):
                           "opencv/2.4.10@laso%s/testing" % "A" * 40)
         self.assertRaises(ConanException, ConanFileReference.loads,
                           "opencv/2.4.10@laso/testing%s" % "A" * 40)
+
+
+class ConanNameTestCase(unittest.TestCase):
+
+    def _check_invalid_format(self, value, *args):
+        with self.assertRaisesRegexp(InvalidNameException, "Valid names"):
+            ConanName.validate_name(value, *args)
+
+    def _check_invalid_type(self, value):
+        with self.assertRaisesRegexp(InvalidNameException, "is not a string"):
+            ConanName.validate_name(value)
+
+    def validate_name_test(self):
+        self.assertIsNone(ConanName.validate_name("string.dot.under-score.123"))
+        self.assertIsNone(ConanName.validate_name("_underscore+123"))
+        self.assertIsNone(ConanName.validate_name("*"))
+        self.assertIsNone(ConanName.validate_name("a" * ConanName._min_chars))
+        self.assertIsNone(ConanName.validate_name("a" * ConanName._max_chars))
+
+    def validate_name_test_invalid_format(self):
+        self._check_invalid_format("-no.dash.start")
+        self._check_invalid_format("a" * (ConanName._min_chars - 1))
+        self._check_invalid_format("a" * (ConanName._max_chars + 1))
+
+    def validate_name_test_invalid_type(self):
+        self._check_invalid_type(123.34)
+        self._check_invalid_type(("item1", "item2",))
+
+    def validate_name_version_test(self):
+        self.assertIsNone(ConanName.validate_name("[vvvv]", version=True))
+
+    def validate_name_version_test_invalid(self):
+        self._check_invalid_format("[no.close.bracket", True)
+        self._check_invalid_format("no.open.bracket]", True)
+
+    def custom_message_test_invalid_type(self):
+        message = "value={value}, type={type}, reason={reason}"
+        value = 1234
+        typename = type(value).__name__
+        reason = "is not a string"
+        with self.assertRaisesRegexp(InvalidNameException,
+                                     message.format(value=value, type=typename, reason=reason)):
+            ConanName.validate_name(value, message=message)
+
+    def custom_message_test_invalid_format(self):
+        message = "value={value}, type={type}, reason={reason}"
+        value = "-no.dash.start"
+        typename = type(value).__name__
+        reason = "is an invalid name"  # Message is longer, but it will validate.
+        with self.assertRaisesRegexp(InvalidNameException,
+                                     message.format(value=value, type=typename, reason=reason)):
+            ConanName.validate_name(value, message=message)

conans/util/config_parser.py

@@ -4,7 +4,7 @@
 
 def get_bool_from_text_value(value):
     """ to be deprecated
-    It has issues, as accepting into the registry whatever=value, as False, withoug
+    It has issues, as accepting into the registry whatever=value, as False, without
     complaining
     """
     return (value == "1" or value.lower() == "yes" or value.lower() == "y" or