Merge branch 'release/0.28.0'

.ci/appveyor/install.bat

@@ -18,3 +18,7 @@ SET CONAN_LOGGING_LEVEL=10
 %PYTHON%/Scripts/pip.exe install -r conans/requirements.txt
 %PYTHON%/Scripts/pip.exe install -r conans/requirements_dev.txt
 %PYTHON%/Scripts/pip.exe install -r conans/requirements_server.txt
+
+C:/Python35/Scripts/pip.exe install meson
+choco install pkgconfiglite -y
+choco install ninja -y

.ci/appveyor/test.bat

@@ -1 +1 @@
-nosetests --with-coverage --verbosity=2 conans.test --processes=4 --process-timeout=1000
+nosetests --with-coverage --verbosity=2 conans.test conans.test_integration --processes=4 --process-timeout=1000

.ci/travis/install.sh

@@ -8,6 +8,8 @@ if [[ "$(uname -s)" == 'Darwin' ]]; then
     brew outdated pyenv || brew upgrade pyenv
     brew install pyenv-virtualenv
     brew install pkg-config
+    brew install ninja
+    brew install meson
 
     if which pyenv > /dev/null; then
         eval "$(pyenv init -)"
@@ -43,7 +45,15 @@ if [[ "$(uname -s)" == 'Darwin' ]]; then
     pyenv activate conan
 else
     sudo apt-get update
-    sudo apt-get install gcc-multilib g++-multilib
+    sudo apt-get install gcc-multilib g++-multilib wget unzip
+
+    wget https://github.com/ninja-build/ninja/releases/download/v1.8.2/ninja-linux.zip
+    unzip ninja-linux.zip
+    sudo mv ninja /usr/bin/ninja
+    rm ninja-linux.zip
+
+    # Will fail if no python3 available
+    pip3 install meson || true
 fi
 
 pip install -r conans/requirements_dev.txt

.ci/travis/run.sh

@@ -8,6 +8,10 @@ if [[ "$(uname -s)" == 'Darwin' ]]; then
         eval "$(pyenv init -)"
     fi
     pyenv activate conan
+    # OSX py3 do not show output in more than 10min causing the build to fail
+    nosetests --with-coverage conans.test conans.test_integration --verbosity=2
+else
+    nosetests --with-coverage conans.test conans.test_integration --verbosity=2 --processes=4 --process-timeout=1000
 fi
 
-nosetests --with-coverage conans.test --verbosity=2 --processes=4 --process-timeout=1000
+

conans/__init__.py

@@ -4,6 +4,7 @@
 from conans.model.options import Options
 from conans.model.settings import Settings
 from conans.client.cmake import CMake
+from conans.client.meson import Meson
 from conans.client.gcc import GCC
 from conans.client.configure_environment import ConfigureEnvironment
 from conans.client.configure_build_environment import (AutoToolsBuildEnvironment, VisualStudioBuildEnvironment)
@@ -16,4 +17,4 @@
 SERVER_CAPABILITIES = [COMPLEX_SEARCH_CAPABILITY, ]
 
 
-__version__ = '0.27.0'
+__version__ = '0.28.0'

conans/client/__init__.py

@@ -0,0 +1,7 @@
+
+def defs_to_string(defs):
+    return " ".join(['-D{0}="{1}"'.format(k, v) for k, v in defs.items()])
+
+
+def join_arguments(args):
+    return " ".join(filter(None, args))

conans/client/build_requires.py

@@ -98,6 +98,6 @@ def _install(self, build_requires_references, build_requires_options, installer)
         self._profile_build_requires.pop("*", None)
         self._profile_build_requires.pop("&!", None)
 
-        installer.install(deps_graph, "")
+        installer.install(deps_graph)
         self._profile_build_requires = old_build_requires  # Restore original values
         return deps_graph

conans/client/client_cache.py

@@ -1,6 +1,5 @@
 import os
 from collections import OrderedDict
-from genericpath import isdir
 
 from conans.client.conf import ConanClientConfigParser, default_client_conf, default_settings_yml
 from conans.client.detect import detect_defaults_settings
@@ -14,6 +13,8 @@
 from conans.model.settings import Settings
 from conans.paths import SimplePaths, CONANINFO, PUT_HEADERS
 from conans.util.files import save, load, normalize
+from conans.util.locks import SimpleLock, ReadLock, WriteLock, NoLock
+
 
 CONAN_CONF = 'conan.conf'
 CONAN_SETTINGS = "settings.yml"
@@ -34,8 +35,30 @@ def __init__(self, base_folder, store_folder, output):
         self._output = output
         self._store_folder = store_folder or self.conan_config.storage_path or self.conan_folder
         self._default_profile = None
+        self._no_lock = None
         super(ClientCache, self).__init__(self._store_folder)
 
+    def _no_locks(self):
+        if self._no_lock is None:
+            self._no_lock = self.conan_config.cache_no_locks
+        return self._no_lock
+
+    def conanfile_read_lock(self, conan_ref):
+        if self._no_locks():
+            return NoLock()
+        return ReadLock(os.path.join(self.conan(conan_ref), "rw"))
+
+    def conanfile_write_lock(self, conan_ref):
+        if self._no_locks():
+            return NoLock()
+        return WriteLock(os.path.join(self.conan(conan_ref), "rw"))
+
+    def package_lock(self, package_ref):
+        if self._no_locks():
+            return NoLock()
+        return SimpleLock(os.path.join(self.conan(package_ref.conan), "locks",
+                                       package_ref.package_id))
+
     @property
     def put_headers_path(self):
         return os.path.join(self.conan_folder, PUT_HEADERS)
@@ -144,7 +167,7 @@ def conan_packages(self, conan_reference):
         packages_dir = self.packages(conan_reference)
         try:
             packages = [dirname for dirname in os.listdir(packages_dir)
-                        if isdir(os.path.join(packages_dir, dirname))]
+                        if os.path.isdir(os.path.join(packages_dir, dirname))]
         except:  # if there isn't any package folder
             packages = []
         return packages
@@ -155,7 +178,7 @@ def conan_builds(self, conan_reference):
         builds_dir = self.builds(conan_reference)
         try:
             builds = [dirname for dirname in os.listdir(builds_dir)
-                      if isdir(os.path.join(builds_dir, dirname))]
+                      if os.path.isdir(os.path.join(builds_dir, dirname))]
         except:  # if there isn't any package folder
             builds = []
         return builds

conans/client/cmake.py

@@ -4,6 +4,7 @@
 from collections import OrderedDict
 from contextlib import contextmanager
 
+from conans.client import defs_to_string, join_arguments
 from conans.errors import ConanException
 from conans.model.conan_file import ConanFile
 from conans.model.settings import Settings
@@ -39,14 +40,16 @@ def _get_env_cmake_system_name():
 class CMake(object):
 
     def __init__(self, settings_or_conanfile, generator=None, cmake_system_name=True,
-                 parallel=True, build_type=None):
+                 parallel=True, build_type=None, toolset=None):
         """
         :param settings_or_conanfile: Conanfile instance (or settings for retro compatibility)
         :param generator: Generator name to use or none to autodetect
         :param cmake_system_name: False to not use CMAKE_SYSTEM_NAME variable,
                True for auto-detect or directly a string with the system name
         :param parallel: Try to build with multiple cores if available
         :param build_type: Overrides default build type comming from settings
+        :param toolset: Toolset name to use (such as llvm-vs2014) or none for default one,
+                applies only to certain generators (e.g. Visual Studio)
         """
         if isinstance(settings_or_conanfile, Settings):
             self._settings = settings_or_conanfile
@@ -71,6 +74,7 @@ def __init__(self, settings_or_conanfile, generator=None, cmake_system_name=True
         self._build_type = self._settings.get_safe("build_type")
 
         self.generator = generator or self._generator()
+        self.toolset = self._toolset(toolset)
         self.build_dir = None
         self._cmake_system_name = _get_env_cmake_system_name()
         if self._cmake_system_name is None:  # Not overwritten using environment
@@ -97,7 +101,7 @@ def build_type(self, build_type):
 
     @property
     def flags(self):
-        return _defs_to_string(self.definitions)
+        return defs_to_string(self.definitions)
 
     @staticmethod
     def options_cmd_line(options, option_upper=True, value_upper=True):
@@ -143,6 +147,11 @@ def _generator(self):
 
         return "Unix Makefiles"
 
+    def _toolset(self, toolset=None):
+        if "CONAN_CMAKE_TOOLSET" in os.environ:
+            return os.environ["CONAN_CMAKE_TOOLSET"]
+        return toolset
+
     def _cmake_compiler_options(self, the_os, arch):
         cmake_definitions = OrderedDict()
 
@@ -171,7 +180,7 @@ def _cmake_cross_build_defines(self, the_os, os_ver):
             platform_os = {"Darwin": "Macos"}.get(platform.system(), platform.system())
             if (platform_os != the_os) or os_ver:  # We are cross building
                 if the_os:
-                    ret["CMAKE_SYSTEM_NAME"] = the_os
+                    ret["CMAKE_SYSTEM_NAME"] = "Darwin" if the_os in ["iOS", "tvOS", "watchOS"] else the_os
                     if os_ver:
                         ret["CMAKE_SYSTEM_VERSION"] = os_ver
                 else:
@@ -225,11 +234,14 @@ def is_multi_configuration(self):
 
     @property
     def command_line(self):
-        return _join_arguments([
+        args = [
             '-G "%s"' % self.generator,
             self.flags,
             '-Wno-dev'
-        ])
+        ]
+        if self.toolset:
+            args.append('-T "%s"' % self.toolset)
+        return join_arguments(args)
 
     def _build_type_definition(self):
         if self._build_type and not self.is_multi_configuration:
@@ -238,7 +250,7 @@ def _build_type_definition(self):
 
     @property
     def runtime(self):
-        return _defs_to_string(self._runtime_definition())
+        return defs_to_string(self._runtime_definition())
 
     def _runtime_definition(self):
         if self._runtime:
@@ -318,10 +330,10 @@ def _configure_new(self, args=None, defs=None, source_dir=None, build_dir=None):
         self.build_dir = build_dir or self.build_dir or self._conanfile.build_folder
 
         mkdir(self.build_dir)
-        arg_list = _join_arguments([
+        arg_list = join_arguments([
             self.command_line,
             args_to_string(args),
-            _defs_to_string(defs),
+            defs_to_string(defs),
             args_to_string([source_dir])
         ])
         command = "cd %s && cmake %s" % (args_to_string([self.build_dir]), arg_list)
@@ -353,7 +365,7 @@ def _build_new(self, args=None, build_dir=None, target=None):
                     args.append("--")
                 args.append("-j%i" % cpu_count())
 
-        arg_list = _join_arguments([
+        arg_list = join_arguments([
             args_to_string([build_dir]),
             self.build_config,
             args_to_string(args)
@@ -362,6 +374,7 @@ def _build_new(self, args=None, build_dir=None, target=None):
         self._conanfile.run(command)
 
     def install(self, args=None, build_dir=None):
+        mkdir(self._conanfile.package_folder)
         if not self.definitions.get("CMAKE_INSTALL_PREFIX"):
             raise ConanException("CMAKE_INSTALL_PREFIX not defined for 'cmake.install()'\n"
                                  "Make sure 'package_folder' is defined")
@@ -386,13 +399,6 @@ def verbose(self):
     def verbose(self, value):
         self.definitions["CMAKE_VERBOSE_MAKEFILE"] = "ON" if value else "OFF"
 
-def _defs_to_string(defs):
-    return " ".join(['-D{0}="{1}"'.format(k, v) for k, v in defs.items()])
-
-
-def _join_arguments(args):
-    return " ".join(filter(None, args))
-
 
 @contextmanager
 def clean_sh_from_path():