| #!/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. |
| |
| """Config class.""" |
| |
| import copy |
| import json |
| import logging |
| import os |
| import re |
| |
| from aidegen.lib import common_util |
| |
| |
| class AidegenConfig(): |
| """Class manages AIDEGen's configurations. |
| |
| Attributes: |
| _config: A dict contains the aidegen config. |
| _config_backup: A dict contains the aidegen config. |
| """ |
| |
| # Constants of AIDEGen config |
| _DEFAULT_CONFIG_FILE = 'aidegen.config' |
| _CONFIG_DIR = os.path.join( |
| os.path.expanduser('~'), '.config', 'asuite', 'aidegen') |
| _CONFIG_FILE_PATH = os.path.join(_CONFIG_DIR, _DEFAULT_CONFIG_FILE) |
| |
| # Constants of enable debugger |
| _ENABLE_DEBUG_CONFIG_DIR = 'enable_debugger' |
| _ENABLE_DEBUG_CONFIG_FILE = 'enable_debugger.iml' |
| _ENABLE_DEBUG_TEMPLATE_FILE = os.path.join( |
| common_util.get_aidegen_root_dir(), 'templates', |
| _ENABLE_DEBUG_CONFIG_DIR, _ENABLE_DEBUG_CONFIG_FILE) |
| _ENABLE_DEBUG_DIR = os.path.join(_CONFIG_DIR, _ENABLE_DEBUG_CONFIG_DIR) |
| _ANDROID_MANIFEST_FILE_NAME = 'AndroidManifest.xml' |
| _DIR_SRC = 'src' |
| _DIR_GEN = 'gen' |
| _ANDROIDMANIFEST_CONTENT = """<?xml version="1.0" encoding="utf-8"?> |
| <manifest xmlns:android="http://schemas.android.com/apk/res/android" |
| android:versionCode="1" |
| android:versionName="1.0" > |
| </manifest> |
| """ |
| DEBUG_ENABLED_FILE_PATH = os.path.join(_ENABLE_DEBUG_DIR, |
| _ENABLE_DEBUG_CONFIG_FILE) |
| |
| def __init__(self): |
| self._config = {} |
| self._config_backup = {} |
| self._create_config_folder() |
| |
| def __enter__(self): |
| self._load_aidegen_config() |
| self._config_backup = copy.deepcopy(self._config) |
| return self |
| |
| def __exit__(self, exc_type, exc_val, exc_tb): |
| self._save_aidegen_config() |
| |
| @property |
| def preferred_version(self): |
| """AIDEGen configuration getter. |
| |
| Returns: |
| The preferred verson item of configuration data if exists, otherwise |
| None. |
| """ |
| return self._config.get('preferred_version', '') |
| |
| @preferred_version.setter |
| def preferred_version(self, preferred_version): |
| """AIDEGen configuration setter. |
| |
| Args: |
| preferred_version: A string, user's preferred version to be set. |
| """ |
| self._config['preferred_version'] = preferred_version |
| |
| def _load_aidegen_config(self): |
| """Load data from configuration file.""" |
| if os.path.exists(self._CONFIG_FILE_PATH): |
| try: |
| with open(self._CONFIG_FILE_PATH, 'r') as cfg_file: |
| self._config = json.load(cfg_file) |
| except ValueError as err: |
| info = '{} format is incorrect, error: {}'.format( |
| self._CONFIG_FILE_PATH, err) |
| logging.info(info) |
| except IOError as err: |
| logging.error(err) |
| raise |
| |
| def _save_aidegen_config(self): |
| """Save data to configuration file.""" |
| if self._is_config_modified(): |
| with open(self._CONFIG_FILE_PATH, 'w') as cfg_file: |
| json.dump(self._config, cfg_file, indent=4) |
| |
| def _is_config_modified(self): |
| """Check if configuration data is modified.""" |
| return any(key for key in self._config if not key in self._config_backup |
| or self._config[key] != self._config_backup[key]) |
| |
| def _create_config_folder(self): |
| """Create the config folder if it doesn't exist.""" |
| if not os.path.exists(self._CONFIG_DIR): |
| os.makedirs(self._CONFIG_DIR) |
| |
| def _gen_enable_debug_sub_dir(self, dir_name): |
| """Generate a dir under enable debug dir. |
| |
| Args: |
| dir_name: A string of the folder name. |
| """ |
| _dir = os.path.join(self._ENABLE_DEBUG_DIR, dir_name) |
| if not os.path.exists(_dir): |
| os.makedirs(_dir) |
| |
| def _gen_empty_androidmanifest(self): |
| """Generate an empty AndroidManifest.xml under enable debug dir. |
| |
| Once the AndroidManifest.xml does not exist or file size is zero, |
| AIDEGen will generate it with default content to prevent the red |
| underline error in IntelliJ. |
| """ |
| _file = os.path.join(self._ENABLE_DEBUG_DIR, |
| self._ANDROID_MANIFEST_FILE_NAME) |
| if not os.path.exists(_file) or os.stat(_file).st_size == 0: |
| common_util.file_generate(_file, self._ANDROIDMANIFEST_CONTENT) |
| |
| def _gen_enable_debugger_config(self, api_level): |
| """Generate the enable_debugger.iml config file. |
| |
| Create the enable_debugger.iml if it doesn't exist. |
| |
| Args: |
| api_level: An integer of API level. |
| """ |
| if not os.path.exists(self.DEBUG_ENABLED_FILE_PATH): |
| content = common_util.read_file_content( |
| self._ENABLE_DEBUG_TEMPLATE_FILE).format(API_LEVEL=api_level) |
| common_util.file_generate(self.DEBUG_ENABLED_FILE_PATH, content) |
| |
| def create_enable_debugger_module(self, api_level): |
| """Create the enable_debugger module. |
| |
| 1. Create two empty folders named src and gen. |
| 2. Create an empty file named AndroidManifest.xml |
| 3. Create the enable_denugger.iml. |
| |
| Args: |
| api_level: An integer of API level. |
| |
| Returns: True if successfully generate the enable debugger module, |
| otherwise False. |
| """ |
| try: |
| self._gen_enable_debug_sub_dir(self._DIR_SRC) |
| self._gen_enable_debug_sub_dir(self._DIR_GEN) |
| self._gen_empty_androidmanifest() |
| self._gen_enable_debugger_config(api_level) |
| return True |
| except (IOError, OSError) as err: |
| logging.warning(('Can\'t create the enable_debugger module in %s.\n' |
| '%s'), self._CONFIG_DIR, err) |
| return False |
| |
| |
| class IdeaProperties(): |
| """Class manages IntelliJ's idea.properties attribute. |
| |
| Class Attributes: |
| _PROPERTIES_FILE: The property file name of IntelliJ. |
| _KEY_FILESIZE: The key name of the maximun file size. |
| _FILESIZE_LIMIT: The value to be set as the max file size. |
| _RE_SEARCH_FILESIZE: A regular expression to find the current max file |
| size. |
| _PROPERTIES_CONTENT: The default content of idea.properties to be |
| generated. |
| |
| Attributes: |
| idea_file: The absolute path of the idea.properties. |
| For example: |
| In Linux, it is ~/.IdeaIC2019.1/config/idea.properties. |
| In Mac, it is ~/Library/Preferences/IdeaIC2019.1/ |
| idea.properties. |
| """ |
| |
| # Constants of idea.properties |
| _PROPERTIES_FILE = 'idea.properties' |
| _KEY_FILESIZE = 'idea.max.intellisense.filesize' |
| _FILESIZE_LIMIT = 100000 |
| _RE_SEARCH_FILESIZE = r'%s\s?=\s?(?P<value>\d+)' % _KEY_FILESIZE |
| _PROPERTIES_CONTENT = """# custom IntelliJ IDEA properties |
| |
| #------------------------------------------------------------------------------- |
| # Maximum size of files (in kilobytes) for which IntelliJ IDEA provides coding |
| # assistance. Coding assistance for large files can affect editor performance |
| # and increase memory consumption. |
| # The default value is 2500. |
| #------------------------------------------------------------------------------- |
| idea.max.intellisense.filesize=100000 |
| """ |
| |
| def __init__(self, config_dir): |
| """IdeaProperties initialize. |
| |
| Args: |
| config_dir: The absolute dir of the idea.properties. |
| """ |
| self.idea_file = os.path.join(config_dir, self._PROPERTIES_FILE) |
| |
| def _set_default_idea_properties(self): |
| """Create the file idea.properties.""" |
| common_util.file_generate(self.idea_file, self._PROPERTIES_CONTENT) |
| |
| def _reset_max_file_size(self): |
| """Reset the max file size value in the idea.properties.""" |
| updated_flag = False |
| properties = common_util.read_file_content(self.idea_file).splitlines() |
| for index, line in enumerate(properties): |
| res = re.search(self._RE_SEARCH_FILESIZE, line) |
| if res and int(res['value']) < self._FILESIZE_LIMIT: |
| updated_flag = True |
| properties[index] = '%s=%s' % (self._KEY_FILESIZE, |
| str(self._FILESIZE_LIMIT)) |
| if updated_flag: |
| common_util.file_generate(self.idea_file, '\n'.join(properties)) |
| |
| def set_max_file_size(self): |
| """Set the max file size parameter in the idea.properties.""" |
| if not os.path.exists(self.idea_file): |
| self._set_default_idea_properties() |
| else: |
| self._reset_max_file_size() |
