# Copyright (c) 2021 Uber Technologies, Inc. # # 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. from __future__ import absolute_import import json import math import shutil from os.path import basename, dirname, join from . import locreader from .filegen import Language, ObjCHeaderFileGenerator, ObjCSourceFileGenerator, SwiftFileGenerator from .loccalc import LOCCalculator from .moduletree import ModuleNode from .util import first_in_dict, first_key, makedir class CocoaPodsProjectGenerator(object): DIR_NAME = dirname(__file__) RESOURCE_DIR = join(DIR_NAME, "resources") def __init__(self, app_root, use_wmo=False, use_dynamic_linking=False, use_deterministic_uuids=True, generate_multiple_pod_projects=False): self.app_root = app_root self.pod_lib_template = self.load_resource("mockcplibtemplate.podspec") self.pod_app_template = self.load_resource("mockcpapptemplate.podspec") self.podfile_template = self.load_resource("mockpodfile") self.app_delegate_template = self.load_resource("mockappdelegate") self.swift_gen = SwiftFileGenerator() self.objc_source_gen = ObjCSourceFileGenerator() self.objc_header_gen = ObjCHeaderFileGenerator() self.loc_calc = LOCCalculator() self.use_wmo = use_wmo self.use_dynamic_linking = use_dynamic_linking self.use_deterministic_uuids = use_deterministic_uuids self.generate_multiple_pod_projects = generate_multiple_pod_projects self.swift_file_size_loc = self.loc_calc.calculate_loc( self.swift_gen.gen_file(3, 3).text, self.swift_gen.language()) self.objc_file_size_loc = self.loc_calc.calculate_loc( self.objc_source_gen.gen_file(3, 3).text, self.objc_source_gen.language()) @property def wmo_state(self): return "YES" if self.use_wmo else "NO" @staticmethod def load_resource(name): with open(join(CocoaPodsProjectGenerator.RESOURCE_DIR, name), "r") as f: return f.read() @staticmethod def copy_resource(name, dest): origin = join(CocoaPodsProjectGenerator.RESOURCE_DIR, name) shutil.copyfile(origin, dest) @staticmethod def write_file(path, text): with open(path, "w") as f: f.write(text) @staticmethod def make_list_str(items, padding=8): return ("\n" + (" " * padding)).join(items) def make_dep_list(self, items): return self.make_list_str(["s.dependency '{0}'".format(i) for i in items]) def make_podfile_dep_list(self, items): return self.make_list_str(["pod '{0}', :path => '{0}/{0}.podspec'".format(i) for i in items], 4) def example_command(self): return "pod install" # Generation Functions def gen_app(self, app_node, node_list, target_swift_loc, target_objc_loc, loc_json_file_path): library_node_list = [n for n in node_list if n.node_type == ModuleNode.LIBRARY] if loc_json_file_path: loc_reader = locreader.LocFileReader() loc_reader.read_loc_file(loc_json_file_path) module_index = {} for n in library_node_list: loc = loc_reader.loc_for_module(n.name) language = loc_reader.language_for_module(n.name) module_index[n.name] = { "files": self.gen_lib_module(module_index, n, loc, language), "loc": loc, "language": language } else: total_code_units = 0 for l in library_node_list: total_code_units += l.code_units total_loc = target_swift_loc + target_objc_loc swift_module_count_percentage = round(float(target_swift_loc) / total_loc, 2) loc_per_unit = total_loc / total_code_units module_index = {} max_swift_index = int(math.ceil((len(library_node_list) * swift_module_count_percentage))) for idx, n in enumerate(library_node_list): language = Language.OBJC if idx >= max_swift_index else Language.SWIFT module_index[n.name] = { "files": self.gen_lib_module(module_index, n, loc_per_unit, language), "loc": loc_per_unit, "language": language } app_module_dir = join(self.app_root, "App") makedir(app_module_dir) app_files = { "AppDelegate.swift": self.gen_app_main(app_node, module_index), "dummy.swift": "", "AppContainer.podspec": self.gen_app_podspec(app_node), } self.copy_resource("Info.plist", join(app_module_dir, "Info.plist")) for name, text in app_files.iteritems(): self.write_file(join(app_module_dir, name), text) if loc_json_file_path: # Copy the LOC file into the generated project. shutil.copyfile(loc_json_file_path, join(self.app_root, basename(loc_json_file_path))) podfile_text = self.gen_podfile(library_node_list) podfile_path = join(self.app_root, "Podfile") self.write_file(podfile_path, podfile_text) serializable_module_index = { key: { "file_count": len(value["files"]), "loc": value["loc"] } for key, value in module_index.items() } with open(join(self.app_root, "module_index.json"), "w") as module_index_json_file: json.dump(serializable_module_index, module_index_json_file) def gen_app_podspec(self, node): module_dep_list = self.make_dep_list([i.name for i in node.deps]) return self.pod_app_template.format(module_dep_list, self.wmo_state) def gen_app_main(self, app_node, module_index): importing_module_name = app_node.deps[0].name file_index = first_in_dict(module_index[importing_module_name]["files"]) language = module_index[importing_module_name]["language"] class_key = first_key(file_index.classes) class_index = first_in_dict(file_index.classes) function_key = first_in_dict(class_index)[0] return self.swift_gen.gen_main(self.app_delegate_template, importing_module_name, class_key, function_key, language) # Library Generation def gen_lib_module(self, module_index, module_node, loc_per_unit, language): # Make Podspec Text deps = self.make_dep_list([i.name for i in module_node.deps]) pod_text = self.pod_lib_template.format(module_node.name, deps, self.wmo_state) # We now return a topologically sorted list of the graph which means that we will already have the # deps of a module inside the module index before we process this one. This allows us to reach into # the generated sources for the dependencies in order to create an instance of their class and # invoke their functions. deps_from_index = [{n.name: module_index[n.name]} for n in module_node.deps] # Make Text if language == Language.SWIFT: file_count = ( max(self.swift_file_size_loc, loc_per_unit) * module_node.code_units) / self.swift_file_size_loc if file_count < 1: raise ValueError( "Lines of code count is too small for the module {} to fit one file, increase it.".format( module_node.name)) files = { "File{}.swift".format(i): self.swift_gen.gen_file(3, 3, deps_from_index) for i in xrange(file_count) } elif language == Language.OBJC: file_count = (max(self.objc_file_size_loc, loc_per_unit) * module_node.code_units) / self.objc_file_size_loc if file_count < 1: raise ValueError( "Lines of code count is too small for the module {} to fit one file, increase it.".format( module_node.name)) files = {} for i in xrange(file_count): objc_source_file = self.objc_source_gen.gen_file( 3, 3, import_list=deps_from_index + ['File{}.h'.format(i)]) files["File{}.m".format(i)] = objc_source_file files["File{}.h".format(i)] = self.objc_header_gen.gen_file(objc_source_file) # Make Module Directories module_dir_path = join(self.app_root, module_node.name) files_dir_path = join(module_dir_path, "Sources") makedir(module_dir_path) makedir(files_dir_path) # Write podspec File pod_path = join(module_dir_path, "{0}.podspec".format(module_node.name)) self.write_file(pod_path, pod_text) # Write Swift Files for file_name, file_obj in files.iteritems(): file_path = join(files_dir_path, file_name) self.write_file(file_path, file_obj.text) file_obj.text = "" # Save memory after write module_node.extra_info = files return files # Podfile Generation def gen_podfile(self, all_nodes): podfile_module_dep_list = self.make_podfile_dep_list([i.name for i in all_nodes]) link_style = ":dynamic" if self.use_dynamic_linking else ":static" use_deterministic_uuids = str(self.use_deterministic_uuids).lower() generate_multiple_pod_projects = str(self.generate_multiple_pod_projects).lower() return self.podfile_template.format( "pod 'AppContainer', :path => 'App/AppContainer.podspec', :appspecs => ['App']", podfile_module_dep_list, link_style, use_deterministic_uuids, generate_multiple_pod_projects)