def _get_source_supporting_files_dir(self, project_name: str,
project_output_dir: str,
project_package: str):
subDirs = project_package.split('.')
outputDir = os.path.join(project_output_dir,
self._get_module_name(project_name), 'src',
'main', 'java', *subDirs)
utils.make_dir(outputDir)
return outputDir
def run(self, output_dir, db, project, project_version, project_namespaces,
project_languages, default_language):
json_dir = os.path.join(output_dir, 'json')
print(' Creating json output directory')
utils.make_dir(json_dir)
for language in project_languages:
language_file = os.path.join(
json_dir, '{}.json'.format(language['slug'].strip().lower()))
language_namespaces = {}
for project_namespace in project_namespaces:
translated_keys = db.get_translated_keys(
project_namespace['id'], language['id'])
count_translated_keys = len(translated_keys)
skip_text = ''
if count_translated_keys == 0:
skip_text = ', skipping it'
print(' Found {} keys for namespace {} with locale {}{}'.
format(len(translated_keys), project_namespace['name'],
language['slug'], skip_text))
if count_translated_keys > 0:
current_namespace = {}
for translated_key in translated_keys:
value = translated_key['value'].strip()
placeholders = utils.get_placeholders(
translated_key['value'])
# Replace placeholders format from ${name} to {{name}}
if placeholders:
for placeholder in placeholders:
value = value.replace(
placeholder.placeholder,
'{{' + placeholder.variableName + '}}')
current_namespace[utils.filter_chars_numbers(
translated_key['key'])] = value
language_namespaces[utils.filter_chars_numbers(
project_namespace['name'])] = current_namespace
with open(language_file, 'w') as json_file:
json.dump(language_namespaces, json_file)
def _get_supporting_files_dir(self, project_output_dir: str):
outputDir = os.path.join(project_output_dir, 'Sources',
'LocaliserExtensions')
utils.make_dir(outputDir)
return outputDir
def run(self, output_dir, db, project, project_version, project_namespaces,
project_languages, default_language):
print(' Creating {} output directory'.format(self.name()))
generator_output_path = os.path.join(
output_dir, self.get_base_output_directory_name())
generator_environment = jinja2.Environment(
loader=jinja2.PackageLoader(self.get_package_name()))
# https://stackoverflow.com/a/35777386
generator_environment.trim_blocks = True
generator_environment.lstrip_blocks = True
utils.make_dir(generator_output_path)
print(' Creating {} supporting files'.format(self.name()))
available_namespaces = []
for project_namespace in project_namespaces:
localised_keys = db.get_namespace_localised_keys(
project_namespace['id'], default_language['id'])
if localised_keys:
available_namespaces.append(project_namespace['name'])
self.generate_namespace_supporting_files(
NamespaceSupportingFilesArguments(
project_name=project['name'],
project_short_identifier=project['short_identifier'],
project_package=project['package'],
project_version=project_version,
namespace_name=project_namespace['name'],
localised_keys=localised_keys,
project_output_dir=generator_output_path,
environment=generator_environment))
self.generate_project_supporting_files(
ProjectSupportingFilesArguments(
project_name=project['name'],
project_language=default_language['slug'],
project_organization=project['organization'],
project_short_identifier=project['short_identifier'],
project_package=project['package'].strip(),
project_version=project_version,
project_namespaces=available_namespaces,
project_android_min_sdk=project['android_min_sdk'],
project_internal_maven_repo=project['internal_maven_repo_url'],
project_nexus_maven_repo=project['nexus_maven_repo_url'],
project_ios_deployment_target=project['ios_deployment_target'].
strip(),
project_output_dir=generator_output_path,
environment=generator_environment))
localisation_base_path = os.path.join(
generator_output_path,
self.get_localisation_directory_base_path(
project['name'], project['short_identifier']))
utils.make_dir(localisation_base_path)
for projectLanguage in project_languages:
language_directory_name = self.get_localisation_directory_name(
slug=projectLanguage['slug'].strip().lower(),
default_slug=default_language['slug'].strip().lower())
print(' Creating {}'.format(language_directory_name))
language_directory = os.path.join(localisation_base_path,
language_directory_name)
utils.make_dir(language_directory)
for project_namespace in project_namespaces:
translated_keys = db.get_translated_keys(
project_namespace['id'], projectLanguage['id'])
count_translated_keys = len(translated_keys)
skip_text = ''
if count_translated_keys == 0:
skip_text = ', skipping it'
print(' Found {} keys for namespace {} with locale {}{}'.
format(len(translated_keys), project_namespace['name'],
projectLanguage['slug'], skip_text))
if count_translated_keys > 0:
output_file_name = self.get_namespace_file_name(
project_namespace['name'])
with open(
os.path.join(language_directory, output_file_name),
'w') as namespaceFile:
template = generator_environment.get_template(
self.get_namespace_template())
namespaceFile.write(
template.render(
keyPrefix=self.get_namespace_key_prefix(
project_namespace['name']),
translatedKeys=translated_keys))
def generate_project_supporting_files(
self, arguments: ProjectSupportingFilesArguments):
outputDir = self._get_source_supporting_files_dir(
arguments.project_name, arguments.project_output_dir,
arguments.project_package)
moduleOutputDir = os.path.join(
arguments.project_output_dir,
self._get_module_name(arguments.project_name))
moduleMainOutputDir = os.path.join(moduleOutputDir, 'src', 'main')
projectGroup = '.'.join(arguments.project_package.split('.')[:2])
moduleName = self._get_module_name(arguments.project_name)
outputFile = os.path.join(
outputDir, '{}Strings.kt'.format(
arguments.project_short_identifier.capitalize()))
with open(outputFile, 'w') as file:
template = arguments.environment.get_template('Project.kt')
file.write(
template.render(
projectName=arguments.project_name,
projectShortIdentifier=arguments.project_short_identifier,
projectPackage=arguments.project_package,
projectNamespaces=[
self._sanitize_namespace(n)
for n in arguments.project_namespaces
]))
self._copy_raw_file(
environment=arguments.environment,
template_name='gradle/gitignore',
destination=os.path.join(arguments.project_output_dir,
'.gitignore'),
)
self._copy_raw_file(environment=arguments.environment,
template_name='gradle/gradlew',
destination=os.path.join(
arguments.project_output_dir, 'gradlew'),
executable=True)
self._copy_raw_file(
environment=arguments.environment,
template_name='gradle/gradlew.bat',
destination=os.path.join(arguments.project_output_dir,
'gradlew.bat'),
)
self._copy_raw_file(
environment=arguments.environment,
template_name='gradle/gradle.properties',
destination=os.path.join(arguments.project_output_dir,
'gradle.properties'),
)
self._copy_raw_file(
environment=arguments.environment,
template_name='gradle/build.gradle',
destination=os.path.join(arguments.project_output_dir,
'build.gradle'),
)
self._copy_raw_file(
environment=arguments.environment,
template_name='gradle/module/proguard-rules.pro',
destination=os.path.join(moduleOutputDir, 'proguard-rules.pro'),
)
wrapperOutDir = os.path.join(arguments.project_output_dir, 'gradle',
'wrapper')
utils.make_dir(wrapperOutDir)
self._copy_raw_file(
environment=arguments.environment,
template_name='gradle/wrapper/gradle-wrapper.properties',
destination=os.path.join(wrapperOutDir,
'gradle-wrapper.properties'),
)
# This is absolute madness. No way of getting a gradle-wrapper.jar from an URL.
# So in order to generate a fully functional project, a cached one in base64 must be used.
with open(os.path.join(wrapperOutDir, 'gradle-wrapper.jar'),
'wb') as file:
template = arguments.environment.get_template(
'gradle/wrapper/gradle-wrapper.jar.b64')
base64data = template.render()
file.write(base64.b64decode(base64data))
outputFile = os.path.join(arguments.project_output_dir,
'manifest.gradle')
with open(outputFile, 'w') as file:
template = arguments.environment.get_template(
'gradle/manifest.gradle')
file.write(
template.render(
projectName=arguments.project_name,
projectShortIdentifier=arguments.project_short_identifier,
projectVersion=arguments.project_version,
projectOrganization=arguments.project_organization,
projectInternalMavenRepo=arguments.
project_internal_maven_repo,
projectNexusMavenRepo=arguments.project_nexus_maven_repo,
projectAndroidMinSdk=arguments.project_android_min_sdk,
projectGroup=projectGroup,
moduleName=moduleName))
outputFile = os.path.join(arguments.project_output_dir, 'README.md')
with open(outputFile, 'w') as file:
template = arguments.environment.get_template('README.md')
file.write(
template.render(
projectName=arguments.project_name,
projectShortIdentifier=arguments.project_short_identifier,
projectInternalMavenRepo=arguments.
project_internal_maven_repo,
projectNexusMavenRepo=arguments.project_nexus_maven_repo,
projectVersion=arguments.project_version,
projectGroup=projectGroup,
moduleName=moduleName))
outputFile = os.path.join(moduleMainOutputDir, 'AndroidManifest.xml')
with open(outputFile, 'w') as file:
template = arguments.environment.get_template(
'gradle/module/AndroidManifest.xml')
file.write(
template.render(projectPackage=arguments.project_package))
self._copy_raw_file(
environment=arguments.environment,
template_name='gradle/module/build.gradle',
destination=os.path.join(moduleOutputDir, 'build.gradle'),
)
outputFile = os.path.join(arguments.project_output_dir, 'LICENSE')
with open(outputFile, 'w') as file:
template = arguments.environment.get_template('LICENSE')
file.write(
template.render(
projectOrganization=arguments.project_organization,
year=time.strftime("%Y")))
outputFile = os.path.join(arguments.project_output_dir,
'settings.gradle')
with open(outputFile, 'w') as file:
template = arguments.environment.get_template(
'gradle/settings.gradle')
file.write(
template.render(libraryModule=self._get_module_name(
arguments.project_name)))