Как iOS-приложение Tinder сократило размер локализаций на 95%

Localization
├── en.lproj
│ ├── Localized.strings
│ └── Localized.stringsdict
├── fr.lproj
│ ├── Localized.strings
│ └── Localized.stringsdict

Localization

├── en.lproj

│ ├── Localized.strings

│ └── Localized.stringsdict

├── fr.lproj

│ ├── Localized.strings

│ └── Localized.stringsdict

TargetA
├── Localization
│ ├── BUILD
│ ├── en.lproj
│ │ ├── TargetA_Localized.strings
│ │ └── TargetA_Localized.stringsdict
│ ├── fr.lproj
│ │ ├── TargetA_Localized.strings
│ │ └── TargetA_Localized.stringsdict
TargetB
├── Localization
│ ├── BUILD
│ ├── en.lproj
│ │ ├── TargetB_Localized.strings
│ │ └── TargetB_Localized.stringsdict
│ ├── fr.lproj
│ │ ├── TargetB_Localized.strings
│ │ └── TargetB_Localized.stringsdict

xxxxxxxxxx

TargetA

├── Localization

│ ├── BUILD

│ ├── en.lproj

│ │ ├── TargetA_Localized.strings

│ │ └── TargetA_Localized.stringsdict

│ ├── fr.lproj

│ │ ├── TargetA_Localized.strings

│ │ └── TargetA_Localized.stringsdict

TargetB

├── Localization

│ ├── BUILD

│ ├── en.lproj

│ │ ├── TargetB_Localized.strings

│ │ └── TargetB_Localized.stringsdict

│ ├── fr.lproj

│ │ ├── TargetB_Localized.strings

│ │ └── TargetB_Localized.stringsdict

/* Title text to display in Account Settings for Email setting */
“account_settings.email” = “Email”;

/* Detail text to display in Account Settings when email needs to be verified */
"account_settings.emailVerifyNow" = "Verify Now";

xxxxxxxxxx

/* Title text to display in Account Settings for Email setting */

“account_settings.email” = “Email”;

​

/* Detail text to display in Account Settings when email needs to be verified */

"account_settings.emailVerifyNow" = "Verify Now";

“account_settings.email” = “Email”;
“account_settings.emailVerifyNow” = “Verify Now”;

xxxxxxxxxx

“account_settings.email” = “Email”;

“account_settings.emailVerifyNow” = “Verify Now”;

Tinder.app
├── keys.json.lzfse
├── en.values.json.lzfse
├── fr.values.json.lzfse
├── he.values.json.lzfse
… (full locale list omitted for brevity)

xxxxxxxxxx

Tinder.app

├── keys.json.lzfse

├── en.values.json.lzfse

├── fr.values.json.lzfse

├── he.values.json.lzfse

… (full locale list omitted for brevity)

NamespacedStringsInfo = provider(
    doc = "Provides lever configuration information.",
    fields = {
        "namespace": "The namespace used to namespace the localized keys.",
        "namespaced_localizations": "The localized strings.",
        "unmodified_localizations": "The unmodified localized strings.",
    },
)

def _namespaced_strings_impl(ctx):
   namespaced_localizations = []
   unmodified_localizations = []
   for src in ctx.files.srcs:
       ...
       ctx.actions.run(
           mnemonic = "NamespaceStrings",
           inputs = [src],
           outputs = [output_file],
           executable = ctx.executable._strings_tool,
           arguments = [args],
           tools = [ctx.executable._namespace_stringsdict_tool],
       )
       namespaced_localizations.append(output_file)
   return [
       NamespacedStringsInfo(
           namespace = ctx.attr.namespace,
           namespaced_localizations = namespaced_localizations,
           unmodified_localizations = unmodified_localizations,
       ),
   ]

namespaced_strings = rule(
   implementation = _namespaced_strings_impl,
   attrs = {
       "srcs": attr.label_list(
           doc = "List of localization files to consume.",
           allow_empty = False,
           allow_files = [
               ".strings",
               ".stringsdict",
           ],
       ),
       "namespace": attr.string(
           doc = "Used to namespace the localized keys.",
           mandatory = True,
       ),
       …
   },
)

xxxxxxxxxx

NamespacedStringsInfo = provider(

    doc = "Provides lever configuration information.",

    fields = {

        "namespace": "The namespace used to namespace the localized keys.",

        "namespaced_localizations": "The localized strings.",

        "unmodified_localizations": "The unmodified localized strings.",

    },

)

​

def _namespaced_strings_impl(ctx):

   namespaced_localizations = []

   unmodified_localizations = []

   for src in ctx.files.srcs:

       ...

       ctx.actions.run(

           mnemonic = "NamespaceStrings",

           inputs = [src],

           outputs = [output_file],

           executable = ctx.executable._strings_tool,

           arguments = [args],

           tools = [ctx.executable._namespace_stringsdict_tool],

       )

       namespaced_localizations.append(output_file)

   return [

       NamespacedStringsInfo(

           namespace = ctx.attr.namespace,

           namespaced_localizations = namespaced_localizations,

           unmodified_localizations = unmodified_localizations,

       ),

   ]

​

namespaced_strings = rule(

   implementation = _namespaced_strings_impl,

   attrs = {

       "srcs": attr.label_list(

           doc = "List of localization files to consume.",

           allow_empty = False,

           allow_files = [

               ".strings",

               ".stringsdict",

           ],

       ),

       "namespace": attr.string(

           doc = "Used to namespace the localized keys.",

           mandatory = True,

       ),

       …

   },

)

MergeStringsInfo = provider(
   doc = "Provides lever configuration information.",
   fields = {
       "namespaced_localizations_json_infos": "A List of Files containing a JSON payload representing the namespaced strings.",
       "namespaced_localizations": "The namespaced localizations.",
   },
)

def _collect_namespaced_strings_info_impl(target, ctx):
   namespaced_localizations_json_infos = []
   namespaced_localizations = []
   if hasattr(ctx.rule.attr, "data"):
       for data in ctx.rule.attr.data:
           if NamespacedStringsInfo in data:
               namespaced_localizations.extend(data[NamespacedStringsInfo].namespaced_localizations)
               localized_strings_by_locale = {}
               localized_stringsdicts_by_locale = {}
               for localization in data[NamespacedStringsInfo].namespaced_localizations:
                   locale = localization.basename.split("_")[0]
                   if localization.extension == "strings":
                       localized_strings_by_locale[locale] = localization.path
                   elif localization.extension == "stringsdict":
                       localized_stringsdicts_by_locale[locale] = localization.path
               json_info = {
                   "namespace": data[NamespacedStringsInfo].namespace,
                   "localized_strings_by_locale": localized_strings_by_locale,
                   "localized_stringsdicts_by_locale": localized_stringsdicts_by_locale,
               }
               namespace_localizations_info = ctx.actions.declare_file(
                   data[NamespacedStringsInfo].namespace + "_namespace_localizations_info.json",
               )
               ctx.actions.write(
                   namespace_localizations_info,
                   json.encode(json_info),
               )
               namespaced_localizations_json_infos.append(namespace_localizations_info)
   namespaced_localizations_json_infos_depset = depset(
       direct = namespaced_localizations_json_infos,
       transitive = [dep[MergeStringsInfo].namespaced_localizations_json_infos for dep in ctx.rule.attr.deps if MergeStringsInfo in dep] if hasattr(ctx.rule.attr, "deps") else [],
   )
   namespaced_localizations_depset = depset(
       direct = namespaced_localizations,
       transitive = [dep[MergeStringsInfo].namespaced_localizations for dep in ctx.rule.attr.deps if MergeStringsInfo in dep] if hasattr(ctx.rule.attr, "deps") else [],
   )
   return [
       MergeStringsInfo(
           namespaced_localizations_json_infos = namespaced_localizations_json_infos_depset,
           namespaced_localizations = namespaced_localizations_depset,
       ),
       OutputGroupInfo(
           namespaced_localizations = namespaced_localizations_depset,
       ),
   ]

collect_namespaced_strings_info = aspect(
   implementation = _collect_namespaced_strings_info_impl,
   attr_aspects = ["deps"],
)

def _merge_strings_impl(ctx):
   for dep in ctx.attr.deps:
       if MergeStringsInfo in dep:
           namespaced_localizations = sets.union(namespaced_localizations, sets.make(dep[MergeStringsInfo].namespaced_localizations.to_list()))
           namespaced_localizations_json_infos = sets.union(namespaced_localizations_json_infos, sets.make(dep[MergeStringsInfo].namespaced_localizations_json_infos.to_list()))
   ...
           ctx.actions.run(
               mnemonic = "MergeStrings",
               inputs = sets.to_list(namespaced_localizations) + sets.to_list(namespaced_localizations_json_infos),
               outputs = [localized_strings_output_file, localized_stringsdict_output_file],
               executable = ctx.executable._merge_strings_tool,
               arguments = [args],
               tools = [ctx.executable._namespace_stringsdict_tool],
           )
           output_files.append(localized_strings_output_file)
           output_files.append(localized_stringsdict_output_file)
   return [
       SmallStringsInfo(merged_localizations = depset(output_files)),
       OutputGroupInfo(merged_localizations = depset(output_files)),
   ]

merge_strings = rule(
   implementation = _merge_strings_impl,
   doc = "Transitively merges all strings assets into a single strings file and stringsdict file. This is done in an effort to reduce bundle size of the app.",
   attrs = {
       "deps": attr.label_list(
           doc = "The dependencies to merge strings from.",
           aspects = [
               collect_namespaced_strings_info,
           ],
       ),
   },
)

xxxxxxxxxx

MergeStringsInfo = provider(

   doc = "Provides lever configuration information.",

   fields = {

       "namespaced_localizations_json_infos": "A List of Files containing a JSON payload representing the namespaced strings.",

       "namespaced_localizations": "The namespaced localizations.",

   },

)

​

def _collect_namespaced_strings_info_impl(target, ctx):

   namespaced_localizations_json_infos = []

   namespaced_localizations = []

   if hasattr(ctx.rule.attr, "data"):

       for data in ctx.rule.attr.data:

           if NamespacedStringsInfo in data:

               namespaced_localizations.extend(data[NamespacedStringsInfo].namespaced_localizations)

               localized_strings_by_locale = {}

               localized_stringsdicts_by_locale = {}

               for localization in data[NamespacedStringsInfo].namespaced_localizations:

                   locale = localization.basename.split("_")[0]

                   if localization.extension == "strings":

                       localized_strings_by_locale[locale] = localization.path

                   elif localization.extension == "stringsdict":

                       localized_stringsdicts_by_locale[locale] = localization.path

               json_info = {

                   "namespace": data[NamespacedStringsInfo].namespace,

                   "localized_strings_by_locale": localized_strings_by_locale,

                   "localized_stringsdicts_by_locale": localized_stringsdicts_by_locale,

               }

               namespace_localizations_info = ctx.actions.declare_file(

                   data[NamespacedStringsInfo].namespace + "_namespace_localizations_info.json",

               )

               ctx.actions.write(

                   namespace_localizations_info,

                   json.encode(json_info),

               )

               namespaced_localizations_json_infos.append(namespace_localizations_info)

   namespaced_localizations_json_infos_depset = depset(

       direct = namespaced_localizations_json_infos,

       transitive = [dep[MergeStringsInfo].namespaced_localizations_json_infos for dep in ctx.rule.attr.deps if MergeStringsInfo in dep] if hasattr(ctx.rule.attr, "deps") else [],

   )

   namespaced_localizations_depset = depset(

       direct = namespaced_localizations,

       transitive = [dep[MergeStringsInfo].namespaced_localizations for dep in ctx.rule.attr.deps if MergeStringsInfo in dep] if hasattr(ctx.rule.attr, "deps") else [],

   )

   return [

       MergeStringsInfo(

           namespaced_localizations_json_infos = namespaced_localizations_json_infos_depset,

           namespaced_localizations = namespaced_localizations_depset,

       ),

       OutputGroupInfo(

           namespaced_localizations = namespaced_localizations_depset,

       ),

   ]

​

collect_namespaced_strings_info = aspect(

   implementation = _collect_namespaced_strings_info_impl,

   attr_aspects = ["deps"],

)

​

def _merge_strings_impl(ctx):

   for dep in ctx.attr.deps:

       if MergeStringsInfo in dep:

           namespaced_localizations = sets.union(namespaced_localizations, sets.make(dep[MergeStringsInfo].namespaced_localizations.to_list()))

           namespaced_localizations_json_infos = sets.union(namespaced_localizations_json_infos, sets.make(dep[MergeStringsInfo].namespaced_localizations_json_infos.to_list()))

   ...

           ctx.actions.run(

               mnemonic = "MergeStrings",

               inputs = sets.to_list(namespaced_localizations) + sets.to_list(namespaced_localizations_json_infos),

               outputs = [localized_strings_output_file, localized_stringsdict_output_file],

               executable = ctx.executable._merge_strings_tool,

               arguments = [args],

               tools = [ctx.executable._namespace_stringsdict_tool],

           )

           output_files.append(localized_strings_output_file)

           output_files.append(localized_stringsdict_output_file)

   return [

       SmallStringsInfo(merged_localizations = depset(output_files)),

       OutputGroupInfo(merged_localizations = depset(output_files)),

   ]

​

merge_strings = rule(

   implementation = _merge_strings_impl,

   doc = "Transitively merges all strings assets into a single strings file and stringsdict file. This is done in an effort to reduce bundle size of the app.",

   attrs = {

       "deps": attr.label_list(

           doc = "The dependencies to merge strings from.",

           aspects = [

               collect_namespaced_strings_info,

           ],

       ),

   },

)

SmallStringsInfo = provider(
   doc = "Provides small strings information.",
   fields = {
       "merged_localizations": "A List of Files containing all merged localizations files.",
   },
)

def _small_strings_impl(ctx):
   strings_files = []
   lzfse_output_files = {}
   output_files = []
   for dep in ctx.attr.deps:
       small_strings_info = dep[SmallStringsInfo]
       localizations = small_strings_info.merged_localizations.to_list()
       for localization in localizations:
           if localization.extension == "stringsdict":
               output_files.append(localization)
           elif localization.extension == "strings":
               locale = localization.dirname.split("/")[-1].split(".")[0]
               strings_files.append(localization)
               lzfse_output_files[locale] = ctx.actions.declare_file(
                   ctx.label.name + "/" + "{locale}.values.json.lzfse".format(locale = locale),
               )
               output_files.append(_create_placeholder_file(ctx, localization))
   if strings_files:
       keys_json_lzfse_file = ctx.actions.declare_file(
           ctx.label.name + "/" + "keys.json.lzfse",
       )
       output_files.append(keys_json_lzfse_file)
       sorted_keys_json_file = ctx.actions.declare_file(
           ctx.label.name + "/" + "sorted_keys.json",
       )
       args = ctx.actions.args()
       args.add_all([
           "compress-strings-keys",
           "--compression-tool-path",
           ctx.executable._compression_tool,
       ])
       for strings_file in strings_files:
           args.add("--merged-localized-strings-filepaths")
           args.add(strings_file.path)

       args.add("--keys-json-lzfse-output-path", keys_json_lzfse_file.path)
       args.add("--sorted-keys-json-output-path", sorted_keys_json_file.path)
       ctx.actions.run(
           outputs = [keys_json_lzfse_file, sorted_keys_json_file],
           inputs = strings_files,
           tools = [ctx.executable._compression_tool],
           executable = ctx.executable._strings_tool,
           arguments = [args],
           mnemonic = "SmallStringsKeys",
       )
       for locale, lzfse_output_file in lzfse_output_files.items():
           args = ctx.actions.args()
           args.add_all([
               "compress-strings-values",
               "--compression-tool-path",
               ctx.executable._compression_tool,
               "--sorted-keys-json-path",
               sorted_keys_json_file.path,
               "--locale",
               locale,
               "--values-json-lzfse-output-path",
               lzfse_output_file.path,
           ])
           for strings_file in strings_files:
               args.add("--merged-localized-strings-filepaths")
               args.add(strings_file.path)
           ctx.actions.run(
               outputs = [lzfse_output_file],
               inputs = strings_files + [sorted_keys_json_file],
               tools = [ctx.executable._compression_tool],
               executable = ctx.executable._strings_tool,
               arguments = [args],
               mnemonic = "SmallStringsValues",
           )
           output_files.append(lzfse_output_file)
   return DefaultInfo(
       files = depset(output_files),
   )

def _create_placeholder_file(ctx, src):
   output = ctx.actions.declare_file(src.dirname + "/" + src.basename)
   ctx.actions.write(
       output,
       "\"placeholder\" = \"_\";\n",
   )
   return output

small_strings = rule(
   implementation = _small_strings_impl,
   attrs = {
       "deps": attr.label_list(
           providers = [
               SmallStringsInfo,
           ],
       ),
   },
)

xxxxxxxxxx

SmallStringsInfo = provider(

   doc = "Provides small strings information.",

   fields = {

       "merged_localizations": "A List of Files containing all merged localizations files.",

   },

)

​

def _small_strings_impl(ctx):

   strings_files = []

   lzfse_output_files = {}

   output_files = []

   for dep in ctx.attr.deps:

       small_strings_info = dep[SmallStringsInfo]

       localizations = small_strings_info.merged_localizations.to_list()

       for localization in localizations:

           if localization.extension == "stringsdict":

               output_files.append(localization)

           elif localization.extension == "strings":

               locale = localization.dirname.split("/")[-1].split(".")[0]

               strings_files.append(localization)

               lzfse_output_files[locale] = ctx.actions.declare_file(

                   ctx.label.name + "/" + "{locale}.values.json.lzfse".format(locale = locale),

               )

               output_files.append(_create_placeholder_file(ctx, localization))

   if strings_files:

       keys_json_lzfse_file = ctx.actions.declare_file(

           ctx.label.name + "/" + "keys.json.lzfse",

       )

       output_files.append(keys_json_lzfse_file)

       sorted_keys_json_file = ctx.actions.declare_file(

           ctx.label.name + "/" + "sorted_keys.json",

       )

       args = ctx.actions.args()

       args.add_all([

           "compress-strings-keys",

           "--compression-tool-path",

           ctx.executable._compression_tool,

       ])

       for strings_file in strings_files:

           args.add("--merged-localized-strings-filepaths")

           args.add(strings_file.path)

​

       args.add("--keys-json-lzfse-output-path", keys_json_lzfse_file.path)

       args.add("--sorted-keys-json-output-path", sorted_keys_json_file.path)

       ctx.actions.run(

           outputs = [keys_json_lzfse_file, sorted_keys_json_file],

           inputs = strings_files,

           tools = [ctx.executable._compression_tool],

           executable = ctx.executable._strings_tool,

           arguments = [args],

           mnemonic = "SmallStringsKeys",

       )

       for locale, lzfse_output_file in lzfse_output_files.items():

           args = ctx.actions.args()

           args.add_all([

               "compress-strings-values",

               "--compression-tool-path",

               ctx.executable._compression_tool,

               "--sorted-keys-json-path",

               sorted_keys_json_file.path,

               "--locale",

               locale,

               "--values-json-lzfse-output-path",

               lzfse_output_file.path,

           ])

           for strings_file in strings_files:

               args.add("--merged-localized-strings-filepaths")

               args.add(strings_file.path)

           ctx.actions.run(

               outputs = [lzfse_output_file],

               inputs = strings_files + [sorted_keys_json_file],

               tools = [ctx.executable._compression_tool],

               executable = ctx.executable._strings_tool,

               arguments = [args],

               mnemonic = "SmallStringsValues",

           )

           output_files.append(lzfse_output_file)

   return DefaultInfo(

       files = depset(output_files),

   )

​

def _create_placeholder_file(ctx, src):

   output = ctx.actions.declare_file(src.dirname + "/" + src.basename)

   ctx.actions.write(

       output,

       "\"placeholder\" = \"_\";\n",

   )

   return output

​

small_strings = rule(

   implementation = _small_strings_impl,

   attrs = {

       "deps": attr.label_list(

           providers = [

               SmallStringsInfo,

           ],

       ),

   },

)