def test_replace_in_file(self): output = ConanOutput(sys.stdout) replace_in_file(self.win_file, "nis", "nus", output=output) replace_in_file(self.bytes_file, "nis", "nus", output=output) content = tools.load(self.win_file) self.assertNotIn("nis", content) self.assertIn("nus", content) content = tools.load(self.bytes_file) self.assertNotIn("nis", content) self.assertIn("nus", content)
def conan_basic_setup_interface_test(self): """ Check conan_basic_setup() interface is the same one for cmake and cmake_multi generators """ conanbuildinfo = load( os.path.join(self.client.current_folder, "conanbuildinfo.cmake")) conanbuildinfo_multi = load( os.path.join(self.client.current_folder, "conanbuildinfo_multi.cmake")) expected = "set(options TARGETS NO_OUTPUT_DIRS SKIP_RPATH KEEP_RPATHS SKIP_STD SKIP_FPIC)" self.assertIn(expected, conanbuildinfo) self.assertIn(expected, conanbuildinfo_multi)
def _get_id(self, with_cppstd, settings_values=None): # Create the conanfile with corresponding settings settings = [ "os", "compiler", ] if with_cppstd: settings += ["cppstd"] conanfile = self.conanfile.format(settings='", "'.join(settings)) self.t.save({"conanfile.py": conanfile}, clean_first=True) # Create the string with the command line settings settings_values = settings_values or dict() settings_values_str = [ "-s {k}={v}".format(k=k, v=v) for k, v in settings_values.items() ] settings_values_str = " ".join(settings_values_str) # Call `conan info` json_file = os.path.join(self.t.current_folder, "tmp.json") self.t.run('info . {} --json="{}"'.format(settings_values_str, json_file)) info_output = self.t.out data = json.loads(load(json_file)) self.assertEqual(len(data), 1) # Return ID, output return data[0]["id"], info_output
def _get_file_conf(self, section, varname=None): """ Gets the section or variable from config file. If the queried element is not found an exception is raised. """ try: if not os.path.exists(self.config_filename): jwt_random_secret = ''.join( random.choice(string.ascii_letters) for _ in range(24)) updown_random_secret = ''.join( random.choice(string.ascii_letters) for _ in range(24)) server_conf = default_server_conf.format( jwt_secret=jwt_random_secret, updown_secret=updown_random_secret) save(self.config_filename, server_conf) if not self._loaded: self._loaded = True # To avoid encoding problems we use our tools.load if six.PY3: self.read_string(tools.load(self.config_filename)) else: self.read(self.config_filename) if varname: section = dict(self.items(section)) return section[varname] else: return self.items(section) except NoSectionError: raise ConanException("No section '%s' found" % section) except Exception as exc: logger.debug(exc) raise ConanException("Invalid configuration, " "missing %s: %s" % (section, varname))
def patch_default_base_profile(conan_api, profile_abs_path): """If we have a profile including default, but the users default in config is that the default is other, we have to change the include""" text = tools.load(profile_abs_path) if "include(default)" in text: # User didn't specified a custom profile default_profile_name = os.path.basename( conan_api._client_cache.default_profile_path) if not os.path.exists(conan_api._client_cache.default_profile_path): conan_api.create_profile(default_profile_name, detect=True) if default_profile_name != "default": # User have a different default profile name # https://github.com/conan-io/conan-package-tools/issues/121 text = text.replace("include(default)", "include(%s)" % default_profile_name) tools.save(profile_abs_path, text)
def get_profiles(client_cache, build_config, base_profile_name=None): base_profile_text = "" if base_profile_name: base_profile_path = os.path.join(client_cache.profiles_path, base_profile_name) base_profile_text = tools.load(base_profile_path) base_profile_name = base_profile_name or "default" tmp = """ include(%s) [settings] %s [options] %s [env] %s [build_requires] %s """ def pairs_lines(items): return "\n".join(["%s=%s" % (k, v) for k, v in items]) settings = pairs_lines(sorted(build_config.settings.items())) options = pairs_lines(build_config.options.items()) env_vars = pairs_lines(build_config.env_vars.items()) br_lines = "" for pattern, build_requires in build_config.build_requires.items(): br_lines += "\n".join( ["%s:%s" % (pattern, br) for br in build_requires]) if os.getenv("CONAN_BUILD_REQUIRES"): brs = os.getenv("CONAN_BUILD_REQUIRES").split(",") brs = ['*:%s' % br.strip() if ":" not in br else br for br in brs] if br_lines: br_lines += "\n" br_lines += "\n".join(brs) profile_text = tmp % (base_profile_name, settings, options, env_vars, br_lines) return profile_text, base_profile_text
def test_unix_to_dos_unit(self): def save_file(contents): tmp = temp_folder() filepath = os.path.join(tmp, "a_file.txt") save(filepath, contents) return filepath fp = save_file(b"a line\notherline\n") if platform.system() != "Windows": output = check_output_runner(["file", fp], stderr=subprocess.STDOUT) self.assertIn("ASCII text", str(output)) self.assertNotIn("CRLF", str(output)) tools.unix2dos(fp) output = check_output_runner(["file", fp], stderr=subprocess.STDOUT) self.assertIn("ASCII text", str(output)) self.assertIn("CRLF", str(output)) else: fc = tools.load(fp) self.assertNotIn("\r\n", fc) tools.unix2dos(fp) fc = tools.load(fp) self.assertIn("\r\n", fc) self.assertEqual("a line\r\notherline\r\n", str(tools.load(fp))) fp = save_file(b"a line\r\notherline\r\n") if platform.system() != "Windows": output = check_output_runner(["file", fp], stderr=subprocess.STDOUT) self.assertIn("ASCII text", str(output)) self.assertIn("CRLF", str(output)) tools.dos2unix(fp) output = check_output_runner(["file", fp], stderr=subprocess.STDOUT) self.assertIn("ASCII text", str(output)) self.assertNotIn("CRLF", str(output)) else: fc = tools.load(fp) self.assertIn("\r\n", fc) tools.dos2unix(fp) fc = tools.load(fp) self.assertNotIn("\r\n", fc) self.assertEqual("a line\notherline\n", str(tools.load(fp)))
def get_command(self, project_file, props_file_path=None, targets=None, upgrade_project=True, build_type=None, arch=None, parallel=True, toolset=None, platforms=None, use_env=False, properties=None, output_binary_log=None, verbosity=None): targets = targets or [] properties = properties or {} command = [] if upgrade_project and not get_env("CONAN_SKIP_VS_PROJECTS_UPGRADE", False): command.append('devenv "%s" /upgrade &&' % project_file) else: self._output.info("Skipped sln project upgrade") build_type = build_type or self._settings.get_safe("build_type") arch = arch or self._settings.get_safe("arch") toolset = toolset or tools.msvs_toolset(self._settings) verbosity = os.getenv("CONAN_MSBUILD_VERBOSITY") or verbosity or "minimal" if not build_type: raise ConanException("Cannot build_sln_command, build_type not defined") if not arch: raise ConanException("Cannot build_sln_command, arch not defined") command.append('msbuild "%s" /p:Configuration="%s"' % (project_file, build_type)) msvc_arch = {'x86': 'x86', 'x86_64': 'x64', 'armv7': 'ARM', 'armv8': 'ARM64'} if platforms: msvc_arch.update(platforms) msvc_arch = msvc_arch.get(str(arch)) try: sln = tools.load(project_file) pattern = re.compile(r"GlobalSection\(SolutionConfigurationPlatforms\)" r"(.*?)EndGlobalSection", re.DOTALL) solution_global = pattern.search(sln).group(1) lines = solution_global.splitlines() lines = [s.split("=")[0].strip() for s in lines] except Exception: pass # TODO: !!! what are we catching here? tools.load? .group(1)? .splitlines? else: config = "%s|%s" % (build_type, msvc_arch) if config not in "".join(lines): self._output.warn("***** The configuration %s does not exist in this solution *****" % config) self._output.warn("Use 'platforms' argument to define your architectures") if output_binary_log: msbuild_version = MSBuild.get_version(self._settings) if msbuild_version >= "15.3": # http://msbuildlog.com/ command.append('/bl' if isinstance(output_binary_log, bool) else '/bl:"%s"' % output_binary_log) else: raise ConanException("MSBuild version detected (%s) does not support " "'output_binary_log' ('/bl')" % msbuild_version) if use_env: command.append('/p:UseEnv=true') if msvc_arch: command.append('/p:Platform="%s"' % msvc_arch) if parallel: command.append('/m:%s' % cpu_count(output=self._output)) if targets: command.append("/target:%s" % ";".join(targets)) if toolset: command.append('/p:PlatformToolset="%s"' % toolset) if verbosity: command.append('/verbosity:%s' % verbosity) if props_file_path: command.append('/p:ForceImportBeforeCppTargets="%s"' % props_file_path) for name, value in properties.items(): command.append('/p:%s="%s"' % (name, value)) return " ".join(command)
def package(self): # Extract the License/s from the header to a file with tools.chdir(self.ZIP_FOLDER_NAME): tmp = tools.load("zlib.h") license_contents = tmp[2:tmp.find("*/", 1)] tools.save("LICENSE", license_contents) # Copy the license files self.copy("LICENSE", src=self.ZIP_FOLDER_NAME, dst=".") # Copy pc file self.copy("*.pc", dst="", keep_path=False) # Copying zlib.h, zutil.h, zconf.h self.copy("*.h", "include", "%s" % self.ZIP_FOLDER_NAME, keep_path=False) self.copy("*.h", "include", "%s" % "_build", keep_path=False) # Copying static and dynamic libs if tools.os_info.is_windows: if self.options.shared: build_dir = os.path.join(self.ZIP_FOLDER_NAME, "_build") self.copy(pattern="*.dll", dst="bin", src=build_dir, keep_path=False) build_dir = os.path.join(self.ZIP_FOLDER_NAME, "_build/lib") self.copy(pattern="*zlibd.lib", dst="lib", src=build_dir, keep_path=False) self.copy(pattern="*zlib.lib", dst="lib", src=build_dir, keep_path=False) self.copy(pattern="*zlib.dll.a", dst="lib", src=build_dir, keep_path=False) else: build_dir = os.path.join(self.ZIP_FOLDER_NAME, "_build/lib") # MinGW self.copy(pattern="libzlibstaticd.a", dst="lib", src=build_dir, keep_path=False) self.copy(pattern="libzlibstatic.a", dst="lib", src=build_dir, keep_path=False) # Visual Studio self.copy(pattern="zlibstaticd.lib", dst="lib", src=build_dir, keep_path=False) self.copy(pattern="zlibstatic.lib", dst="lib", src=build_dir, keep_path=False) lib_path = os.path.join(self.package_folder, "lib") suffix = "d" if self.settings.build_type == "Debug" else "" if self.settings.compiler == "Visual Studio": current_lib = os.path.join(lib_path, "zlibstatic%s.lib" % suffix) os.rename(current_lib, os.path.join(lib_path, "zlib%s.lib" % suffix)) elif self.settings.compiler == "gcc": current_lib = os.path.join(lib_path, "libzlibstatic.a") os.rename(current_lib, os.path.join(lib_path, "libzlib.a")) else: build_dir = os.path.join(self.ZIP_FOLDER_NAME) if self.options.shared: if self.settings.os == "Macos": self.copy(pattern="*.dylib", dst="lib", src=build_dir, keep_path=False) else: self.copy(pattern="*.so*", dst="lib", src=build_dir, keep_path=False) else: self.copy(pattern="*.a", dst="lib", src=build_dir, keep_path=False)
def load_profile(profile_abs_path, client_cache): text = tools.load(profile_abs_path) profile, _ = _load_profile(text, os.path.dirname(profile_abs_path), client_cache.profiles_path) return profile