140 lines
4.6 KiB
Python
140 lines
4.6 KiB
Python
# Copyright 2019 The Bazel Authors. All rights reserved.
|
|
#
|
|
# 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.
|
|
|
|
"""Utilities for maprule."""
|
|
|
|
def resolve_locations(ctx, strategy, d):
|
|
"""Resolve $(location) references in the values of a dictionary.
|
|
|
|
Args:
|
|
ctx: the 'ctx' argument of the rule implementation function
|
|
strategy: a struct with an 'as_path(string) -> string' function
|
|
d: {string: string} dictionary; values may contain $(location) references
|
|
for labels declared in the rule's 'srcs' and 'tools' attributes
|
|
|
|
Returns:
|
|
{string: string} dict, same as 'd' except "$(location)" references are
|
|
resolved.
|
|
"""
|
|
location_expressions = []
|
|
parts = {}
|
|
was_anything_to_resolve = False
|
|
for k, v in d.items():
|
|
# Look for "$(location ...)" or "$(locations ...)", resolve if found.
|
|
# _validate_attributes already ensured that there's at most one $(location/s ...) in "v".
|
|
if "$(location" in v:
|
|
tokens = v.split("$(location")
|
|
was_anything_to_resolve = True
|
|
closing_paren = tokens[1].find(")")
|
|
location_expressions.append("$(location" + tokens[1][:closing_paren + 1])
|
|
parts[k] = (tokens[0], tokens[1][closing_paren + 1:])
|
|
else:
|
|
location_expressions.append("")
|
|
|
|
resolved = {}
|
|
if was_anything_to_resolve:
|
|
# Resolve all $(location) expressions in one go. Should be faster than resolving them
|
|
# one-by-one.
|
|
all_location_expressions = "<split_here>".join(location_expressions)
|
|
all_resolved_locations = ctx.expand_location(all_location_expressions)
|
|
resolved_locations = strategy.as_path(all_resolved_locations).split("<split_here>")
|
|
|
|
i = 0
|
|
|
|
# Starlark dictionaries have a deterministic order of iteration, so the element order in
|
|
# "resolved_locations" matches the order in "location_expressions", i.e. the previous
|
|
# iteration order of "d".
|
|
for k, v in d.items():
|
|
if location_expressions[i]:
|
|
head, tail = parts[k]
|
|
resolved[k] = head + resolved_locations[i] + tail
|
|
else:
|
|
resolved[k] = v
|
|
i += 1
|
|
else:
|
|
resolved = d
|
|
|
|
return resolved
|
|
|
|
def fail_if_errors(errors):
|
|
"""Reports errors and fails the rule.
|
|
|
|
Args:
|
|
errors: list of strings; the errors to report. At most 10 are reported.
|
|
"""
|
|
if errors:
|
|
# Don't overwhelm the user; report up to ten errors.
|
|
fail("\n".join(errors[:10]))
|
|
|
|
def _as_windows_path(s):
|
|
"""Returns the input path as a Windows path (replaces all of "/" with "\")."""
|
|
return s.replace("/", "\\")
|
|
|
|
def _unchanged_path(s):
|
|
"""Returns the input string (path) unchanged."""
|
|
return s
|
|
|
|
def _create_cmd_action(
|
|
ctx,
|
|
outputs,
|
|
command,
|
|
inputs = None,
|
|
env = None,
|
|
progress_message = None,
|
|
mnemonic = None,
|
|
manifests_from_tools = None):
|
|
"""Create one action using cmd.exe."""
|
|
ctx.actions.run(
|
|
inputs = inputs or [],
|
|
outputs = outputs,
|
|
executable = "cmd.exe",
|
|
env = env,
|
|
arguments = ["/C", command],
|
|
progress_message = progress_message or "Running cmd.exe command",
|
|
mnemonic = mnemonic or "CmdExeCommand",
|
|
input_manifests = manifests_from_tools,
|
|
)
|
|
|
|
def _create_bash_action(
|
|
ctx,
|
|
outputs,
|
|
command,
|
|
inputs = None,
|
|
env = None,
|
|
progress_message = None,
|
|
mnemonic = None,
|
|
manifests_from_tools = None):
|
|
"""Create one action using Bash."""
|
|
ctx.actions.run_shell(
|
|
inputs = inputs or [],
|
|
outputs = outputs,
|
|
env = env,
|
|
command = command,
|
|
progress_message = progress_message or "Running Bash command",
|
|
mnemonic = mnemonic or "BashCommand",
|
|
input_manifests = manifests_from_tools,
|
|
)
|
|
|
|
# Action creation utilities for cmd.exe actions.
|
|
CMD_STRATEGY = struct(
|
|
as_path = _as_windows_path,
|
|
create_action = _create_cmd_action,
|
|
)
|
|
|
|
# Action creation utilities for Bash actions.
|
|
BASH_STRATEGY = struct(
|
|
as_path = _unchanged_path,
|
|
create_action = _create_bash_action,
|
|
)
|