| #!/usr/bin/env python3 |
| # |
| # Copyright 2018 - The Android Open Source Project |
| # |
| # Licensed under the Apache License, Version 2.0 (the "License"); |
| # you may not use this file except in compliance with the License. |
| # You may obtain a copy of the License at |
| # |
| # http://www.apache.org/licenses/LICENSE-2.0 |
| # |
| # Unless required by applicable law or agreed to in writing, software |
| # distributed under the License is distributed on an "AS IS" BASIS, |
| # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| # See the License for the specific language governing permissions and |
| # limitations under the License. |
| |
| """It is an AIDEGen sub task : generate the project files. |
| |
| This module generate IDE project files from templates. |
| |
| Typical usage example: |
| |
| generate_ide_project_file(project_info) |
| """ |
| |
| import logging |
| import os |
| import pathlib |
| import shutil |
| |
| from aidegen import constant |
| from aidegen.lib import common_util |
| from aidegen.lib.eclipse_project_file_gen import EclipseConf |
| |
| # FACET_SECTION is a part of iml, which defines the framework of the project. |
| _FACET_SECTION = '''\ |
| <facet type="android" name="Android"> |
| <configuration /> |
| </facet>''' |
| _SOURCE_FOLDER = (' <sourceFolder url=' |
| '"file://%s" isTestSource="%s" />\n') |
| _CONTENT_URL = ' <content url="file://%s">\n' |
| _END_CONTENT = ' </content>\n' |
| _ORDER_ENTRY = (' <orderEntry type="module-library" exported="">' |
| '<library><CLASSES><root url="jar://%s!/" /></CLASSES>' |
| '<JAVADOC /><SOURCES /></library></orderEntry>\n') |
| _MODULE_ORDER_ENTRY = (' <orderEntry type="module" ' |
| 'module-name="%s" />') |
| _MODULE_SECTION = (' <module fileurl="file:///$PROJECT_DIR$/%s.iml"' |
| ' filepath="$PROJECT_DIR$/%s.iml" />') |
| _SUB_MODULES_SECTION = (' <module fileurl="file:///%s" ' |
| 'filepath="%s" />') |
| _VCS_SECTION = ' <mapping directory="%s" vcs="Git" />' |
| _FACET_TOKEN = '@FACETS@' |
| _SOURCE_TOKEN = '@SOURCES@' |
| _MODULE_DEP_TOKEN = '@MODULE_DEPENDENCIES@' |
| _MODULE_TOKEN = '@MODULES@' |
| _VCS_TOKEN = '@VCS@' |
| _JAVA_FILE_PATTERN = '%s/*.java' |
| _ROOT_DIR = constant.AIDEGEN_ROOT_PATH |
| _IDEA_DIR = os.path.join(_ROOT_DIR, 'templates/idea') |
| _TEMPLATE_IML_PATH = os.path.join(_ROOT_DIR, 'templates/module-template.iml') |
| _IDEA_FOLDER = '.idea' |
| _MODULES_XML = 'modules.xml' |
| _VCS_XML = 'vcs.xml' |
| _TEMPLATE_MODULES_PATH = os.path.join(_IDEA_DIR, _MODULES_XML) |
| _TEMPLATE_VCS_PATH = os.path.join(_IDEA_DIR, _VCS_XML) |
| _DEPENDENCIES_IML = 'dependencies.iml' |
| _COPYRIGHT_FOLDER = 'copyright' |
| _CODE_STYLE_FOLDER = 'codeStyles' |
| _COMPILE_XML = 'compiler.xml' |
| _MISC_XML = 'misc.xml' |
| _ANDROID_MANIFEST = 'AndroidManifest.xml' |
| _IML_EXTENSION = '.iml' |
| _FRAMEWORK_JAR = os.sep + 'framework.jar' |
| _HIGH_PRIORITY_JARS = [_FRAMEWORK_JAR] |
| _GIT_FOLDER_NAME = '.git' |
| # Support gitignore by symbolic link to aidegen/data/gitignore_template. |
| _GITIGNORE_FILE_NAME = '.gitignore' |
| _GITIGNORE_REL_PATH = 'tools/asuite/aidegen/data/gitignore_template' |
| _GITIGNORE_ABS_PATH = os.path.join(constant.ANDROID_ROOT_PATH, |
| _GITIGNORE_REL_PATH) |
| # Support code style by symbolic link to aidegen/data/AndroidStyle_aidegen.xml. |
| _CODE_STYLE_REL_PATH = 'tools/asuite/aidegen/data/AndroidStyle_aidegen.xml' |
| _CODE_STYLE_SRC_PATH = os.path.join(constant.ANDROID_ROOT_PATH, |
| _CODE_STYLE_REL_PATH) |
| |
| _ECLIP_SRC_ENTRY = '<classpathentry exported="true" kind="src" path="{}"/>\n' |
| _ECLIP_LIB_ENTRY = '<classpathentry exported="true" kind="lib" path="{}"/>\n' |
| _ECLIP_TEMPLATE_PATH = os.path.join(_ROOT_DIR, 'templates/eclipse/eclipse.xml') |
| _ECLIP_EXTENSION = '.classpath' |
| _ECLIP_SRC_TOKEN = '@SRC@' |
| _ECLIP_LIB_TOKEN = '@LIB@' |
| |
| # b/121256503: Prevent duplicated iml names from breaking IDEA. |
| # Use a map to cache in-using(already used) iml project file names. |
| _USED_NAME_CACHE = dict() |
| |
| |
| def get_unique_iml_name(abs_module_path): |
| """Create a unique iml name if needed. |
| |
| If the name of last sub folder is used already, prefixing it with prior sub |
| folder names as a candidate name. If finally, it's unique, storing in |
| _USED_NAME_CACHE as: { abs_module_path:unique_name }. The cts case and UX of |
| IDE view are the main reasons why using module path strategy but not name of |
| module directly. Following is the detailed strategy: |
| 1. While loop composes a sensible and shorter name, by checking unique to |
| finish the loop and finally add to cache. |
| Take ['cts', 'tests', 'app', 'ui'] an example, if 'ui' isn't occupied, |
| use it, else try 'cts_ui', then 'cts_app_ui', the worst case is whole |
| three candidate names are occupied already. |
| 2. 'Else' for that while stands for no suitable name generated, so trying |
| 'cts_tests_app_ui' directly. If it's still non unique, e.g., module path |
| cts/xxx/tests/app/ui occupied that name already, appending increasing |
| sequence number to get a unique name. |
| |
| Args: |
| abs_module_path: Full module path string. |
| |
| Return: |
| String: A unique iml name. |
| """ |
| if abs_module_path in _USED_NAME_CACHE: |
| return _USED_NAME_CACHE[abs_module_path] |
| |
| uniq_name = abs_module_path.strip(os.sep).split(os.sep)[-1] |
| if any(uniq_name == name for name in _USED_NAME_CACHE.values()): |
| parent_path = os.path.relpath(abs_module_path, |
| constant.ANDROID_ROOT_PATH) |
| sub_folders = parent_path.split(os.sep) |
| zero_base_index = len(sub_folders) - 1 |
| # Start compose a sensible, shorter and unique name. |
| while zero_base_index > 0: |
| uniq_name = '_'.join( |
| [sub_folders[0], '_'.join(sub_folders[zero_base_index:])]) |
| zero_base_index = zero_base_index - 1 |
| if uniq_name not in _USED_NAME_CACHE.values(): |
| break |
| else: |
| # b/133393638: To handle several corner cases. |
| uniq_name_base = parent_path.strip(os.sep).replace(os.sep, '_') |
| i = 0 |
| uniq_name = uniq_name_base |
| while uniq_name in _USED_NAME_CACHE.values(): |
| i = i + 1 |
| uniq_name = '_'.join([uniq_name_base, str(i)]) |
| _USED_NAME_CACHE[abs_module_path] = uniq_name |
| logging.debug('Unique name for module path of %s is %s.', abs_module_path, |
| uniq_name) |
| return uniq_name |
| |
| |
| def _generate_intellij_project_file(project_info, iml_path_list=None): |
| """Generates IntelliJ project file. |
| |
| Args: |
| project_info: ProjectInfo instance. |
| iml_path_list: An optional list of submodule's iml paths, default None. |
| """ |
| source_dict = dict.fromkeys( |
| list(project_info.source_path['source_folder_path']), False) |
| source_dict.update( |
| dict.fromkeys(list(project_info.source_path['test_folder_path']), True)) |
| project_info.iml_path, _ = _generate_iml( |
| constant.ANDROID_ROOT_PATH, project_info.project_absolute_path, |
| source_dict, list(project_info.source_path['jar_path']), |
| project_info.project_relative_path) |
| _generate_modules_xml(project_info.project_absolute_path, iml_path_list) |
| project_info.git_path = _generate_vcs_xml( |
| project_info.project_absolute_path) |
| _copy_constant_project_files(project_info.project_absolute_path) |
| |
| |
| def generate_ide_project_files(projects): |
| """Generate IDE project files by a list of ProjectInfo instances. |
| |
| For multiple modules case, we call _generate_intellij_project_file to |
| generate iml file for submodules first and pass submodules' iml file paths |
| as an argument to function _generate_intellij_project_file when we generate |
| main module.iml file. In this way, we can add submodules' dependencies iml |
| and their own iml file paths to main module's module.xml. |
| |
| Args: |
| projects: A list of ProjectInfo instances. |
| """ |
| |
| if projects[0].config.ide_name == constant.IDE_ECLIPSE: |
| generate_eclipse_project_files(projects) |
| else: |
| # Initialization |
| _USED_NAME_CACHE.clear() |
| for project in projects[1:]: |
| _generate_intellij_project_file(project) |
| iml_paths = [project.iml_path for project in projects[1:]] |
| _generate_intellij_project_file(projects[0], iml_paths) |
| _merge_project_vcs_xmls(projects) |
| |
| |
| def _generate_eclipse_project_file(project_info): |
| """Generates Eclipse project files. |
| |
| Args: |
| project_info: ProjectInfo instance. |
| """ |
| eclipse_configure = EclipseConf(project_info) |
| eclipse_configure.generate_project_file() |
| source_dict = dict.fromkeys( |
| list(project_info.source_path['source_folder_path']), False) |
| source_dict.update( |
| dict.fromkeys(list(project_info.source_path['test_folder_path']), True)) |
| source_dict.update( |
| dict.fromkeys(list(project_info.source_path['r_java_path']), True)) |
| project_info.iml_path = _generate_classpath( |
| project_info.project_absolute_path, list(sorted(source_dict)), |
| list(project_info.source_path['jar_path'])) |
| |
| |
| def generate_eclipse_project_files(projects): |
| """Generate Eclipse project files by a list of ProjectInfo instances. |
| |
| Args: |
| projects: A list of ProjectInfo instances. |
| """ |
| for project in projects: |
| _generate_eclipse_project_file(project) |
| |
| |
| def _copy_constant_project_files(target_path): |
| """Copy project files to target path with error handling. |
| |
| This function would copy compiler.xml, misc.xml, codeStyles folder and |
| copyright folder to target folder. Since these files aren't mandatory in |
| IntelliJ, it only logs when an IOError occurred. |
| |
| Args: |
| target_path: A folder path to copy content to. |
| """ |
| try: |
| _copy_to_idea_folder(target_path, _COPYRIGHT_FOLDER) |
| _copy_to_idea_folder(target_path, _CODE_STYLE_FOLDER) |
| code_style_target_path = os.path.join(target_path, _IDEA_FOLDER, |
| _CODE_STYLE_FOLDER, 'Project.xml') |
| # Base on current working directory to prepare the relevant location |
| # of the symbolic link file, and base on the symlink file location to |
| # prepare the relevant code style source path. |
| rel_target = os.path.relpath(code_style_target_path, os.getcwd()) |
| rel_source = os.path.relpath(_CODE_STYLE_SRC_PATH, |
| os.path.dirname(code_style_target_path)) |
| logging.debug('Relative target symlink path: %s.', rel_target) |
| logging.debug('Relative code style source path: %s.', rel_source) |
| os.symlink(rel_source, rel_target) |
| # Create .gitignore if it doesn't exist. |
| _generate_git_ignore(target_path) |
| shutil.copy( |
| os.path.join(_IDEA_DIR, _COMPILE_XML), |
| os.path.join(target_path, _IDEA_FOLDER, _COMPILE_XML)) |
| shutil.copy( |
| os.path.join(_IDEA_DIR, _MISC_XML), |
| os.path.join(target_path, _IDEA_FOLDER, _MISC_XML)) |
| except IOError as err: |
| logging.warning('%s can\'t copy the project files\n %s', target_path, |
| err) |
| |
| |
| def _copy_to_idea_folder(target_path, folder_name): |
| """Copy folder to project .idea path. |
| |
| Args: |
| target_path: Path of target folder. |
| folder_name: Name of target folder. |
| """ |
| target_folder_path = os.path.join(target_path, _IDEA_FOLDER, folder_name) |
| # Existing folder needs to be removed first, otherwise it will raise |
| # IOError. |
| if os.path.exists(target_folder_path): |
| shutil.rmtree(target_folder_path) |
| shutil.copytree(os.path.join(_IDEA_DIR, folder_name), target_folder_path) |
| |
| |
| def _handle_facet(content, path): |
| """Handle facet part of iml. |
| |
| If the module is an Android app, which contains AndroidManifest.xml, it |
| should have a facet of android, otherwise we don't need facet in iml. |
| |
| Args: |
| content: String content of iml. |
| path: Path of the module. |
| |
| Returns: |
| String: Content with facet handled. |
| """ |
| facet = '' |
| if os.path.isfile(os.path.join(path, _ANDROID_MANIFEST)): |
| facet = _FACET_SECTION |
| return content.replace(_FACET_TOKEN, facet) |
| |
| |
| def _handle_module_dependency(root_path, content, jar_dependencies): |
| """Handle module dependency part of iml. |
| |
| Args: |
| root_path: Android source tree root path. |
| content: String content of iml. |
| jar_dependencies: List of the jar path. |
| |
| Returns: |
| String: Content with module dependency handled. |
| """ |
| module_library = '' |
| dependencies = [] |
| # Reorder deps in the iml generated by IntelliJ by inserting priority jars. |
| for jar_path in jar_dependencies: |
| if any((jar_path.endswith(high_priority_jar)) |
| for high_priority_jar in _HIGH_PRIORITY_JARS): |
| module_library += _ORDER_ENTRY % os.path.join(root_path, jar_path) |
| else: |
| dependencies.append(jar_path) |
| |
| # IntelliJ indexes jars as dependencies from iml by the ascending order. |
| # Without sorting, the order of jar list changes everytime. Sort the jar |
| # list to keep the jar dependencies in consistency. It also can help us to |
| # discover potential issues like duplicated classes. |
| for jar_path in sorted(dependencies): |
| module_library += _ORDER_ENTRY % os.path.join(root_path, jar_path) |
| return content.replace(_MODULE_DEP_TOKEN, module_library) |
| |
| |
| def _is_project_relative_source(source, relative_path): |
| """Check if the relative path of a file is a source relative path. |
| |
| Check if the file path starts with the relative path or the relative is an |
| Android source tree root path. |
| |
| Args: |
| source: The file path to be checked. |
| relative_path: The relative path to be checked. |
| |
| Returns: |
| True if the file is a source relative path, otherwise False. |
| """ |
| abs_path = common_util.get_abs_path(relative_path) |
| if common_util.is_android_root(abs_path): |
| return True |
| if _is_source_under_relative_path(source, relative_path): |
| return True |
| return False |
| |
| |
| def _handle_source_folder(root_path, content, source_dict, is_module, |
| relative_path): |
| """Handle source folder part of iml. |
| |
| It would make the source folder group by content. |
| e.g. |
| <content url="file://$MODULE_DIR$/a"> |
| <sourceFolder url="file://$MODULE_DIR$/a/b" isTestSource="False" /> |
| <sourceFolder url="file://$MODULE_DIR$/a/test" isTestSource="True" /> |
| <sourceFolder url="file://$MODULE_DIR$/a/d/e" isTestSource="False" /> |
| </content> |
| |
| Args: |
| root_path: Android source tree root path. |
| content: String content of iml. |
| source_dict: A dictionary of sources path with a flag to identify the |
| path is test or source folder in IntelliJ. |
| e.g. |
| {'path_a': True, 'path_b': False} |
| is_module: True if it is module iml, otherwise it is dependencies iml. |
| relative_path: Relative path of the module. |
| |
| Returns: |
| String: Content with source folder handled. |
| """ |
| source_list = list(source_dict.keys()) |
| source_list.sort() |
| src_builder = [] |
| if is_module: |
| # Set the content url to module's path since it's the iml of target |
| # project which only has it's sub-folders in source_list. |
| src_builder.append( |
| _CONTENT_URL % os.path.join(root_path, relative_path)) |
| for path, is_test_flag in sorted(source_dict.items()): |
| if _is_project_relative_source(path, relative_path): |
| src_builder.append(_SOURCE_FOLDER % (os.path.join( |
| root_path, path), is_test_flag)) |
| src_builder.append(_END_CONTENT) |
| else: |
| for path, is_test_flag in sorted(source_dict.items()): |
| path = os.path.join(root_path, path) |
| src_builder.append(_CONTENT_URL % path) |
| src_builder.append(_SOURCE_FOLDER % (path, is_test_flag)) |
| src_builder.append(_END_CONTENT) |
| return content.replace(_SOURCE_TOKEN, ''.join(src_builder)) |
| |
| |
| def _trim_same_root_source(source_list): |
| """Trim the source which has the same root. |
| |
| The source list may contain lots of duplicate sources. |
| For example: |
| a/b, a/b/c, a/b/d |
| We only need to import a/b in iml, this function is used to trim redundant |
| sources. |
| |
| Args: |
| source_list: Sorted list of the sources. |
| |
| Returns: |
| List: The trimmed source list. |
| """ |
| tmp_source_list = [source_list[0]] |
| for src_path in source_list: |
| if ''.join([tmp_source_list[-1], |
| os.sep]) not in ''.join([src_path, os.sep]): |
| tmp_source_list.append(src_path) |
| return sorted(tmp_source_list) |
| |
| |
| def _is_source_under_relative_path(source, relative_path): |
| """Check if a source file is a project relative path file. |
| |
| Args: |
| source: Android source file path. |
| relative_path: Relative path of the module. |
| |
| Returns: |
| True if source file is a project relative path file, otherwise False. |
| """ |
| return source == relative_path or source.startswith(relative_path + os.sep) |
| |
| |
| # pylint: disable=too-many-locals |
| def _generate_iml(root_path, module_path, source_dict, jar_dependencies, |
| relative_path): |
| """Generate iml file. |
| |
| Args: |
| root_path: Android source tree root path. |
| module_path: Absolute path of the module. |
| source_dict: A dictionary of sources path with a flag to distinguish the |
| path is test or source folder in IntelliJ. |
| e.g. |
| {'path_a': True, 'path_b': False} |
| jar_dependencies: List of the jar path. |
| relative_path: Relative path of the module. |
| |
| Returns: |
| String: The absolute paths of module iml and dependencies iml. |
| """ |
| template = common_util.read_file_content(_TEMPLATE_IML_PATH) |
| |
| # Separate module and dependencies source folder |
| project_source_dict = {} |
| for source in list(source_dict): |
| if _is_project_relative_source(source, relative_path): |
| is_test = source_dict.get(source) |
| source_dict.pop(source) |
| project_source_dict.update({source: is_test}) |
| |
| # Generate module iml. |
| module_content = _handle_facet(template, module_path) |
| module_content = _handle_source_folder( |
| root_path, module_content, project_source_dict, True, relative_path) |
| # b/121256503: Prevent duplicated iml names from breaking IDEA. |
| module_name = get_unique_iml_name(module_path) |
| |
| module_iml_path = os.path.join(module_path, module_name + _IML_EXTENSION) |
| |
| dep_name = _get_dependencies_name(module_name) |
| dep_sect = _MODULE_ORDER_ENTRY % dep_name |
| module_content = module_content.replace(_MODULE_DEP_TOKEN, dep_sect) |
| common_util.file_generate(module_iml_path, module_content) |
| |
| # Generate dependencies iml. |
| dependencies_content = template.replace(_FACET_TOKEN, '') |
| dependencies_content = _handle_source_folder( |
| root_path, dependencies_content, source_dict, False, relative_path) |
| dependencies_content = _handle_module_dependency( |
| root_path, dependencies_content, jar_dependencies) |
| dependencies_iml_path = os.path.join(module_path, dep_name + _IML_EXTENSION) |
| common_util.file_generate(dependencies_iml_path, dependencies_content) |
| logging.debug('Paired iml names are %s, %s', module_iml_path, |
| dependencies_iml_path) |
| # The dependencies_iml_path is use for removing the file itself in unittest. |
| return module_iml_path, dependencies_iml_path |
| |
| |
| def _generate_classpath(module_path, source_list, jar_dependencies): |
| """Generate .classpath file. |
| |
| Args: |
| module_path: Absolute path of the module. |
| source_list: A list of sources path. |
| jar_dependencies: List of the jar path. |
| |
| Returns: |
| String: The absolute paths of .classpath. |
| """ |
| template = common_util.read_file_content(_ECLIP_TEMPLATE_PATH) |
| |
| src_list = [_ECLIP_SRC_ENTRY.format(s) for s in source_list] |
| template = template.replace(_ECLIP_SRC_TOKEN, ''.join(src_list)) |
| |
| lib_list = [_ECLIP_LIB_ENTRY.format(j) for j in jar_dependencies] |
| template = template.replace(_ECLIP_LIB_TOKEN, ''.join(lib_list)) |
| |
| classpath_path = os.path.join(module_path, _ECLIP_EXTENSION) |
| |
| common_util.file_generate(classpath_path, template) |
| |
| return classpath_path |
| |
| |
| def _get_dependencies_name(module_name): |
| """Get module's dependencies iml name which will be written in module.xml. |
| |
| Args: |
| module_name: The name will be appended to "dependencies-". |
| |
| Returns: |
| String: The joined dependencies iml file name, e.g. "dependencies-core" |
| """ |
| return '-'.join([constant.KEY_DEPENDENCIES, module_name]) |
| |
| |
| def _generate_modules_xml(module_path, iml_path_list=None): |
| """Generate modules.xml file. |
| |
| IntelliJ uses modules.xml to import which modules should be loaded to |
| project. Only in multiple modules case will we pass iml_path_list of |
| submodules' dependencies and their iml file paths to add them into main |
| module's module.xml file. The dependencies iml file names will be changed |
| from original dependencies.iml to dependencies-[module_name].iml, |
| e.g. dependencies-core.iml for core.iml. |
| |
| Args: |
| module_path: Path of the module. |
| iml_path_list: A list of submodule iml paths. |
| """ |
| content = common_util.read_file_content(_TEMPLATE_MODULES_PATH) |
| |
| # b/121256503: Prevent duplicated iml names from breaking IDEA. |
| module_name = get_unique_iml_name(module_path) |
| |
| file_name = os.path.splitext(module_name)[0] |
| dep_name = _get_dependencies_name(file_name) |
| module_list = [ |
| _MODULE_SECTION % (module_name, module_name), |
| _MODULE_SECTION % (dep_name, dep_name) |
| ] |
| if iml_path_list: |
| for iml_path in iml_path_list: |
| iml_dir, iml_name = os.path.split(iml_path) |
| dep_file = _get_dependencies_name(iml_name) |
| dep_path = os.path.join(iml_dir, dep_file) |
| module_list.append(_SUB_MODULES_SECTION % (dep_path, dep_path)) |
| module_list.append(_SUB_MODULES_SECTION % (iml_path, iml_path)) |
| module = '\n'.join(module_list) |
| content = content.replace(_MODULE_TOKEN, module) |
| target_path = os.path.join(module_path, _IDEA_FOLDER, _MODULES_XML) |
| common_util.file_generate(target_path, content) |
| |
| |
| def _generate_vcs_xml(module_path): |
| """Generate vcs.xml file. |
| |
| IntelliJ use vcs.xml to record version control software's information. |
| Since we are using a single project file, it will only contain the |
| module itself. If there is no git folder inside, it would find it in |
| parent's folder. |
| |
| Args: |
| module_path: Path of the module. |
| |
| Return: |
| String: A module's git path. |
| """ |
| git_path = module_path |
| while not os.path.isdir(os.path.join(git_path, _GIT_FOLDER_NAME)): |
| git_path = str(pathlib.Path(git_path).parent) |
| if git_path == os.sep: |
| logging.warning('%s can\'t find its .git folder', module_path) |
| return None |
| _write_vcs_xml(module_path, [git_path]) |
| return git_path |
| |
| |
| def _write_vcs_xml(module_path, git_paths): |
| """Write the git path into vcs.xml. |
| |
| For main module, the vcs.xml should include all modules' git path. |
| For submodules, there is only one git path in vcs.xml. |
| |
| Args: |
| module_path: Path of the module. |
| git_paths: A list of git path. |
| """ |
| _vcs_content = '\n'.join([_VCS_SECTION % p for p in git_paths if p]) |
| content = common_util.read_file_content(_TEMPLATE_VCS_PATH) |
| content = content.replace(_VCS_TOKEN, _vcs_content) |
| target_path = os.path.join(module_path, _IDEA_FOLDER, _VCS_XML) |
| common_util.file_generate(target_path, content) |
| |
| |
| def _merge_project_vcs_xmls(projects): |
| """Merge sub projects' git paths into main project's vcs.xml. |
| |
| After all projects' vcs.xml are generated, collect the git path of each |
| projects and write them into main project's vcs.xml. |
| |
| Args: |
| projects: A list of ProjectInfo instances. |
| """ |
| main_project_absolute_path = projects[0].project_absolute_path |
| git_paths = [project.git_path for project in projects] |
| _write_vcs_xml(main_project_absolute_path, git_paths) |
| |
| |
| def _generate_git_ignore(target_folder): |
| """Generate .gitignore file. |
| |
| In target_folder, if there's no .gitignore file, uses symlink() to generate |
| one to hide project content files from git. |
| |
| Args: |
| target_folder: An absolute path string of target folder. |
| """ |
| # TODO(b/133639849): Provide a common method to create symbolic link. |
| # TODO(b/133641803): Move out aidegen artifacts from Android repo. |
| try: |
| gitignore_abs_path = os.path.join(target_folder, _GITIGNORE_FILE_NAME) |
| rel_target = os.path.relpath(gitignore_abs_path, os.getcwd()) |
| rel_source = os.path.relpath(_GITIGNORE_ABS_PATH, target_folder) |
| logging.debug('Relative target symlink path: %s.', rel_target) |
| logging.debug('Relative ignore_template source path: %s.', rel_source) |
| if not os.path.exists(gitignore_abs_path): |
| os.symlink(rel_source, rel_target) |
| except OSError as err: |
| logging.error('Not support to run aidegen on Windows.\n %s', err) |
