uberpoet/blazeprojectgen.py

#  Copyright (c) 2018 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 BlazeProjectGenerator(object):
    DIR_NAME = dirname(__file__)
    RESOURCE_DIR = join(DIR_NAME, "resources")

    def __init__(self, app_root, blaze_app_root, use_wmo=False, flavor='buck'):
        self.app_root = app_root
        self.blaze_app_root = blaze_app_root
        self.bzl_lib_template = self.load_resource("mock{}libtemplate.bzl".format(flavor))
        self.bzl_app_template = self.load_resource("mock{}apptemplate.bzl".format(flavor))
        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.flavor = flavor
        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(BlazeProjectGenerator.RESOURCE_DIR, name), "r") as f:
            return f.read()

    @staticmethod
    def copy_resource(name, dest):
        origin = join(BlazeProjectGenerator.RESOURCE_DIR, name)
        shutil.copyfile(origin, dest)

    @staticmethod
    def copy_resource_dir(name, dest):
        origin = join(BlazeProjectGenerator.RESOURCE_DIR, name)
        shutil.copytree(origin, dest)

    @staticmethod
    def write_file(path, text):
        with open(path, "w") as f:
            f.write(text)

    @staticmethod
    def make_list_str(items):
        return (",\n" + (" " * 8)).join(items)

    def make_dep_list(self, items):
        return self.make_list_str(["'//{0}:{0}'".format(i) for i in items])

    def make_scheme_list(self, items):
        return self.make_list_str(
            ["{2: <20} :'/{0}/{1}:{1}Scheme'".format(self.blaze_app_root, i, "'{}'".format(i)) for i in items])

    def example_command(self):
        if self.flavor == 'buck':
            return "buck project //App:App"
        elif self.flavor == 'bazel':
            return "Use Tulsi or XCHammer to generate an Xcode project."

    # 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_build_file = "BUCK" if self.flavor == 'buck' else "BUILD"
        app_files = {
            "AppDelegate.swift": self.gen_app_main(app_node, module_index),
            app_build_file: self.gen_app_build(app_node, library_node_list),
        }

        self.copy_resource("Info.plist", join(app_module_dir, "Info.plist"))

        if self.flavor == 'buck':
            self.copy_resource("mockbuckconfig", join(self.app_root, ".buckconfig"))
        elif self.flavor == 'bazel':
            self.copy_resource("mockbazelworkspace", join(self.app_root, "WORKSPACE"))
            self.copy_resource_dir("tools", join(self.app_root, "tools"))

        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)))

        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_build(self, node, all_nodes):
        module_dep_list = self.make_dep_list([i.name for i in node.deps])
        module_scheme_list = self.make_scheme_list([i.name for i in all_nodes])
        return self.bzl_app_template.format(module_scheme_list, 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):
        deps = self.make_dep_list([i.name for i in module_node.deps])
        build_text = self.bzl_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 BUCK or BUILD Files
        build_name = "BUCK" if self.flavor == 'buck' else "BUILD"
        build_path = join(module_dir_path, build_name)
        self.write_file(build_path, build_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