mirror of
https://github.com/google/blockly.git
synced 2026-01-04 15:40:08 +01:00
407 lines
14 KiB
Bash
Executable File
407 lines
14 KiB
Bash
Executable File
#!/bin/bash
|
|
|
|
# This file makes extensive use of perl for the purpose of extracting and
|
|
# replacing string (regex) patterns in a way that is both GNU and macOS
|
|
# compatible.
|
|
#
|
|
# Common perl flags used (also described at https://perldoc.perl.org/perlrun):
|
|
# -e : Used to execute perl programs on the command line
|
|
# -p : Assumes an input loop around script. Prints every processed line.
|
|
# -n : Assumes an input loop around script. Does not print every line.
|
|
# -i : Used for in-place editing. Used in commands for find/replace.
|
|
# -l[octnum] : Assigns the output record separator "$/" as an octal number. If
|
|
# octnum is not present, sets output record separator to the current
|
|
# value of the input record separator "$\".
|
|
#
|
|
# Common perl commands found:
|
|
# 1. perl -pi -e 's/regex/replacement/modifiers'
|
|
# This command does an in-place search-and-replace. The global ("/g") modifier
|
|
# causes it to replace all occurrences, rather than only the first match.
|
|
# 2. perl -ne 'print m/regex/modifiers'
|
|
# This command returns a string containing the regex match (designated by the
|
|
# capture group "()" in the regex). This will return the first match, unless
|
|
# the global modifier is specified, in which case, it will return all matches.
|
|
# If this command is used without a capture group it returns true or false (in
|
|
# the form a truthy or falsy value).
|
|
# 3. perl -nle 'print $& while m{regex}modifiers'
|
|
# Similar to (2), but returns regex matches separated by newlines.
|
|
# The "m{regex}modifiers" is equivalent to "m/regex/modifiers" syntax.
|
|
#
|
|
# Additional information on regex:
|
|
# This script makes use of some advanced regex syntax such as "capture groups"
|
|
# and "lookaround assertions".
|
|
# Additionally, characters are escaped from regex with a backslash "\".
|
|
# Single quotes need to be escaped in both regex and the string, resulting in
|
|
# '\'' being used to represent a single quote character.
|
|
# For a reference to syntax of regular expressions in Perl, see:
|
|
# https://perldoc.perl.org/perlre
|
|
|
|
#######################################
|
|
# Logging functions.
|
|
#######################################
|
|
COLOR_NONE="\033[0m"
|
|
GREEN="\033[0;32m"
|
|
BLUE="\033[0;34m"
|
|
ORANGE="\033[0;33m"
|
|
RED="\033[0;31m"
|
|
success() {
|
|
echo -e "${GREEN}[SUCCESS]:${COLOR_NONE} $*" >&2
|
|
}
|
|
inf() {
|
|
echo -e "${BLUE}[INFO]:${COLOR_NONE} $*" >&2
|
|
}
|
|
warn() {
|
|
echo -e "${ORANGE}[WARN]:${COLOR_NONE} $*" >&2
|
|
}
|
|
err() {
|
|
echo -e "${RED}[ERROR]:${COLOR_NONE} $*" >&2
|
|
}
|
|
reenter_instructions() {
|
|
echo -e "${ORANGE}$*${COLOR_NONE}" >&2
|
|
}
|
|
|
|
#######################################
|
|
# Checks whether the provided filepath exists.
|
|
# Arguments:
|
|
# The filepath to check for existence.
|
|
# Optional: Whether to log an error.
|
|
#######################################
|
|
verify-filepath() {
|
|
local filepath="$1"
|
|
local no_log="$2"
|
|
if [[ ! -f "${filepath}" ]]; then
|
|
if [[ -z "${no_log}" || "${no_log}" == 'true' ]]; then
|
|
err "File ${filepath} does not exist"
|
|
fi
|
|
return 1
|
|
fi
|
|
}
|
|
|
|
#######################################
|
|
# Creates a commit with a message based on the specified step and file.
|
|
# Arguments:
|
|
# Which conversion step this message is for.
|
|
# The filepath of the file being converted.
|
|
#######################################
|
|
commit-step() {
|
|
local step="$1"
|
|
local filepath="$2"
|
|
if [[ -z "${step}" ]]; then
|
|
err "Missing argument (1-4)"
|
|
return 1
|
|
fi
|
|
if [[ -z "${filepath}" ]]; then
|
|
err "Missing argument filepath"
|
|
return 1
|
|
fi
|
|
verify-filepath "${filepath}"
|
|
if [[ $? -eq 1 ]]; then return 1; fi
|
|
|
|
local message=''
|
|
case $1 in
|
|
1)
|
|
message="Migrate ${filepath} to ES6 const/let"
|
|
;;
|
|
2)
|
|
message="Migrate ${filepath} to goog.module"
|
|
;;
|
|
3)
|
|
message="Migrate ${filepath} named requires"
|
|
;;
|
|
4)
|
|
message="clang-format ${filepath}"
|
|
;;
|
|
*)
|
|
err 'INVALID ARGUMENT'
|
|
return 1
|
|
;;
|
|
esac
|
|
git add .
|
|
if [[ -z $(git status --porcelain) ]]; then
|
|
success "Nothing to commit"
|
|
return 0
|
|
fi
|
|
git commit -m "${message}"
|
|
success "created commit with message: \"${message}\""
|
|
}
|
|
|
|
#######################################
|
|
# Extracts a list of properties that are accessed on the specified module name.
|
|
# Excludes any matches
|
|
# Arguments:
|
|
# The module name to find properties accessed for.
|
|
# The modules required by the specified module as a single string.
|
|
# The filepath to extract requires from.
|
|
# Optional: The top-level module.
|
|
# Outputs:
|
|
# Writes list of properties to stdout as items separated by spaces.
|
|
#######################################
|
|
getPropertiesAccessed() {
|
|
local module_name="$1"
|
|
local requires="$2"
|
|
local filepath="$3"
|
|
local top_module_name="$4"
|
|
# Get any strings that follow "$module_name.", excluding matches for
|
|
# "$module_name.prototype" and remove list item duplicates (sort -u).
|
|
local properties_accessed=$(perl -nle 'print $& while m{(?<='"${module_name}"'\.)(?!prototype)\w+}g' "${filepath}" | sort -u)
|
|
|
|
# Get a list of any requires that are a child of $module_name.
|
|
# Ex: Blockly.utils.dom is a child of Blockly.utils, this would return "dom"
|
|
local requires_overlap=$(echo "${requires}" | perl -nle 'print $& while m{(?<='"${module_name}"'\.)\w+}g')
|
|
# Detect if there was any overlap.
|
|
if [[ -n "${requires_overlap}" ]]; then
|
|
while read -r requires_overlap_prop; do
|
|
# Removes any instances of $requires_overlap_prop. Includes regex
|
|
# lookarounds so that it does not simply match string contains.
|
|
# Ex: if $requires_overlap is "Svg", then it would update the list
|
|
# "isTargetInput mouseToSvg noEvent Svg" to
|
|
# "isTargetInput mouseToSvg noEvent " (note that mouseToSvg is unchanged).
|
|
properties_accessed=$(echo "${properties_accessed}" | perl -pe 's/(?<!\w)'"${requires_overlap_prop}"'(?!\w)//g')
|
|
done <<<"${requires_overlap}"
|
|
fi
|
|
|
|
# Fix formatting (remove extra whitespace) and delimit the list with spaces.
|
|
properties_accessed=$(echo "${properties_accessed}" | perl -pe 's/\s+/ /g' | xargs)
|
|
|
|
echo "${properties_accessed}"
|
|
}
|
|
|
|
#######################################
|
|
# Extracts a list of requires defined in the file in the form of a single string
|
|
# of items separated by newlines.
|
|
# Arguments:
|
|
# The filepath to extract requires from.
|
|
# Outputs:
|
|
# Writes list of requires to stdout as items separated by newlines.
|
|
#######################################
|
|
getRequires() {
|
|
local filepath="$1"
|
|
# Extracts all strings that start with goog.require(' or goog.requireType('
|
|
# up until the ending single quote.
|
|
# Ex: "goog.require('Blockly.utils')" would extract "Blockly.utils"
|
|
local requires=$(perl -nle 'print $& while m{(?:(?<=^goog.require\('\'')|(?<=^goog.requireType\('\''))[^'\'']+}g' "${filepath}")
|
|
echo "${requires}"
|
|
}
|
|
|
|
#######################################
|
|
# Runs step 2 of the automated conversion.
|
|
# Arguments:
|
|
# The filepath of the file being converted.
|
|
#######################################
|
|
step2 () {
|
|
local filepath="$1"
|
|
|
|
inf "Updating goog.provide declaration..."
|
|
perl -pi -e 's/^goog\.provide(\([^\)]+\)\;)/goog\.module\1\ngoog.module.declareLegacyNamespace\(\)\;/' "${filepath}"
|
|
|
|
inf "Extracting module name..."
|
|
local module_name=$(perl -ne 'print m/(?<=^goog\.module\('\'')([^'\'']+)/' "${filepath}")
|
|
if [[ -z "${module_name}" ]]; then
|
|
err "Could not extract module name"
|
|
return 1
|
|
fi
|
|
inf "Extracted module name \"${module_name}\""
|
|
|
|
if [[ $(grep "${module_name} = " "${filepath}") ]]; then
|
|
local class_name=$(echo "${module_name}" | perl -ne 'print m/(\w+)$/')
|
|
inf "Found class \"${class_name}\" in file."
|
|
inf "Updating class declaration..."
|
|
perl -pi -e 's/^('"${module_name}"') =/const '"${class_name}"' =/g' "${filepath}"
|
|
|
|
inf "Updating local references to class..."
|
|
perl -pi -e 's/'"${module_name}"'(?!['\''\w])/'"${class_name}"'/g' "${filepath}"
|
|
|
|
inf "Appending class export to end of file..."
|
|
echo "" >> "${filepath}"
|
|
echo "exports = ${class_name};" >> "${filepath}"
|
|
|
|
npm run build:deps
|
|
|
|
success "Completed automated conversion to goog.module. Please manually review before committing."
|
|
return 0
|
|
fi
|
|
|
|
# No top level class.
|
|
inf 'Updating top-level property declarations...'
|
|
perl -pi -e 's/^'"${module_name}"'\.([^ ]+) =/const \1 =/g' "${filepath}"
|
|
|
|
# Extract specific properties accessed so that properties from requires that
|
|
# are children of the module aren't changed.
|
|
# Ex: The module Blockly.utils shouldn't update Blockly.utils.dom (since it is
|
|
# a require from another module.
|
|
local requires=$(getRequires "${filepath}")
|
|
local properties_accessed=$(getPropertiesAccessed "${module_name}" "${requires}" "${filepath}")
|
|
inf "Updating local references to module..."
|
|
for property in $(echo "${properties_accessed}"); do
|
|
inf "Updating references of ${module_name}.${property} to ${property}..."
|
|
perl -pi -e 's/'"${module_name}"'\.'"${property}"'(?!\w)/'"${property}"'/g' "${filepath}"
|
|
done
|
|
|
|
npm run build:deps
|
|
success "Completed automation for step 2. Please manually review and add exports for non-private top-level functions."
|
|
}
|
|
|
|
#######################################
|
|
# Runs step 3 of the automated conversion.
|
|
# Arguments:
|
|
# The filepath of the file being converted.
|
|
#######################################
|
|
step3() {
|
|
inf "Extracting module name..."
|
|
local module_name=$(perl -ne 'print m/(?<=^goog\.module\('\'')([^'\'']+)/' "${filepath}")
|
|
if [[ -z "${module_name}" ]]; then
|
|
err "Could not extract module name"
|
|
return 1
|
|
fi
|
|
inf "Extracted module name \"${module_name}\""
|
|
|
|
local requires=$(getRequires "${filepath}")
|
|
|
|
# Process each require
|
|
echo "${requires}" | while read -r require; do
|
|
inf "Processing require \"${require}\""
|
|
local usages=$(perl -nle 'print $& while m{'"${require}"'(?!'\'')}g' "${filepath}" | wc -l)
|
|
|
|
if [[ "${usages}" -eq "0" ]]; then
|
|
warn "Unused require \"${require}\""
|
|
continue
|
|
fi
|
|
|
|
local require_name=$(echo "${require}" | perl -pe 's/(\w+\.)+(\w+)/\2/g')
|
|
inf "Updating require declaration for ${require}..."
|
|
perl -pi -e 's/^(goog\.(require|requireType)\('\'"${require}"\''\);)/const '"${require_name}"' = \1/' "${filepath}"
|
|
|
|
# Parse property access of module
|
|
local direct_access_count=$(perl -nle 'print $& while m{'"${require}"'[^\.'\'']}g' "${filepath}" | wc -l)
|
|
local properties_accessed=$(getPropertiesAccessed "${require}" "${requires}" "${filepath}")
|
|
|
|
# Remove $module_name in case it is a child of $require.
|
|
# Ex: Blockly.utils.dom would be a child of Blockly, module_overlap would be
|
|
# "utils"
|
|
local module_overlap=$(echo "${module_name}" | perl -nle 'print $& while m{(?<='"${require}"'\.)\w+}g')
|
|
if [[ -n "${module_overlap}" ]]; then
|
|
properties_accessed=$(echo "${properties_accessed}" | perl -pe 's/'"${module_overlap}"'//g')
|
|
# Trim any extra whitespace created.
|
|
properties_accessed=$(echo "${properties_accessed}" | xargs)
|
|
fi
|
|
|
|
if [[ -n "${properties_accessed}" ]]; then
|
|
local comma_properties=$(echo "${properties_accessed}" | perl -pe 's/\s+/, /g' | perl -pe 's/, $//')
|
|
inf "Detected references of ${require}: ${comma_properties}"
|
|
|
|
for require_prop in $(echo "${properties_accessed}"); do
|
|
inf "Updating references of ${require}.${require_prop} to ${require_name}.${require_prop}..."
|
|
perl -pi -e 's/'"${require}"'\.'"${require_prop}"'(?!\w)/'"${require_name}"'\.'"${require_prop}"'/g' "${filepath}"
|
|
done
|
|
fi
|
|
|
|
inf "Updating direct references of ${require} to ${require_name}..."
|
|
perl -pi -e 's/'"${require}"'(?!['\''\w\.])/'"${require_name}"'/g' "${filepath}"
|
|
done
|
|
|
|
local missing_requires=$(perl -nle'print $& while m{(?<!'\'')Blockly(\.\w+)+}g' "${filepath}")
|
|
missing_requires=$(echo "${missing_requires}" | tr ' ' '\n' | sort -u)
|
|
if [[ -n "${missing_requires}" ]]; then
|
|
# Search for the string goog.require('Blockly') or goog.requireType('Blockly')
|
|
local has_blockly_require=$(perl -ne 'print m/goog\.(?:require|requireType)\('\''Blockly'\''\)/' "${filepath}")
|
|
if [[ -n "${has_blockly_require}" ]]; then
|
|
warn 'Blockly detected as a require.'
|
|
warn "Potentially missing requires for:\n${missing_requires}\nPlease manually review."
|
|
else
|
|
err "Missing requires for:\n${missing_requires}\nPlease manually fix."
|
|
fi
|
|
fi
|
|
|
|
success "Completed automation for step 3. Please manually review and reorder requires."
|
|
}
|
|
|
|
#######################################
|
|
# Runs step 4 of the automated conversion.
|
|
# Arguments:
|
|
# The filepath of the file being converted.
|
|
#######################################
|
|
step4() {
|
|
inf "Running clang-format"
|
|
npx clang-format -i "${filepath}"
|
|
}
|
|
|
|
#######################################
|
|
# Runs the specified step.
|
|
# Arguments:
|
|
# Which step to run.
|
|
# The filepath of the file being converted.
|
|
#######################################
|
|
run-step() {
|
|
local step="$1"
|
|
local filepath="$2"
|
|
if [[ -z "${step}" ]]; then
|
|
err "Missing argument (1-4)"
|
|
return 1
|
|
fi
|
|
if [[ -z "${filepath}" ]]; then
|
|
err "Missing argument filepath"
|
|
return 1
|
|
fi
|
|
verify-filepath "${filepath}"
|
|
if [[ $? -eq 1 ]]; then return 1; fi
|
|
|
|
case "${step}" in
|
|
2)
|
|
step2 "${filepath}"
|
|
;;
|
|
3)
|
|
step3 "${filepath}"
|
|
;;
|
|
4)
|
|
step4 "${filepath}"
|
|
;;
|
|
*)
|
|
err "INVALID ARGUMENT ${step}"
|
|
return 1
|
|
;;
|
|
esac
|
|
}
|
|
|
|
#######################################
|
|
# Prints usage information.
|
|
#######################################
|
|
help() {
|
|
echo "Conversion steps:"
|
|
echo " 1. Use IDE to convert var to let/const"
|
|
echo " 2. Rewrite the goog.provide statement as goog.module and explicitly enumerate exports"
|
|
echo " 3. Rewrite goog.requires statements and add missing requires (often skipped for simple files)"
|
|
echo " 4. Run clang-format on the whole file"
|
|
echo ""
|
|
echo "Usage: $0 [-h] [-c <step> <filepath>|-s <step> <filepath>]"
|
|
echo " -h Display help and exit"
|
|
echo " -c <step> <filepath> Create a commit for the specified step [1-4]"
|
|
echo " -s <step> <filepath> Run the specified step [2-4]"
|
|
}
|
|
|
|
#######################################
|
|
# Main entry point.
|
|
#######################################
|
|
main() {
|
|
if [ "$1" = "" ]; then
|
|
help
|
|
else
|
|
local filepath=""
|
|
# Support filepath as first argument.
|
|
verify-filepath "$1" "false"
|
|
if [[ $? -eq 0 ]]; then
|
|
filepath="$1"
|
|
shift
|
|
fi
|
|
|
|
local command="$1"
|
|
shift
|
|
case $command in
|
|
-c) commit-step "$@" "${filepath}" ;;
|
|
-s) run-step "$@" "${filepath}" ;;
|
|
*) err "INVALID ARGUMENT ${command}";;
|
|
esac
|
|
fi
|
|
}
|
|
|
|
main "$@"
|