tools/devshell/report-bug - fuchsia - Git at Google

 #!/bin/bash
 # Copyright 2021 The Fuchsia Authors. All rights reserved.
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.

 #### CATEGORY=Software delivery
 ### report a bug for an fx command
 ## usage:
 ##        fx report-bug [<flags>] <command> [<args>]
 ##          Report an issue on an fx <command>.
 ##
 ##          <flags>: [optional] include:
 ##              -v, --verbose: verbose output
 ##              -h, --help : provide this help.
 ##
 ##          <command>: any fx command.
 ##
 ##          <args>: [optional] the arguments passed to the fx <command> that
 ##                  caused the issue being reported, for inclusion in the bug
 ##                  report.
 ##
 ## This tool will help file a bug on bugs.fuchsia.dev for the given command. It
 ## parses the COMPONENT and OWNERS lines of the command's metadata or, if those
 ## aren't present, the `per-file` and `# COMPONENT:` lines of their OWNERS
 ## files. This parsing allows `report-bug` to specify which bugs.fuchsia.dev
 ## component the bug should be filed in and who should be added to the "Cc:"
 ## field.
 ##
 ## `fx report-bug` will print out a URL that can be pasted into a browser to
 ## create a bug with the appropriate fields pre-filled. Just add the details
 ## and submit it.
 ##
 ## Be sure to include the <args> so the the bug report can show the exact
 ## command invocation that exhibited the reported issue.

 set -e

 # Globals
 readonly DEFAULT_COMPONENT="Tools>fx"
 verbose=false

 # shellcheck source=/dev/null
 source "$(cd "$(dirname "${BASH_SOURCE[0]}")" >/dev/null 2>&1 && pwd)"/lib/vars.sh || exit $?
 fx-config-read

 # Look for an `include <filename>` line in an OWNERS file. Return the filename.
 function parse_owners_file_for_includes() {
   local file=$1

   grep -E "^include " "${file}" | # Find lines with the token followed by a space or colon.
     cut -d" " -f2 |               # Use only the part after the =.
     cut -d"#" -f1 |               # Strip any additional comments.
     xargs -n 1                    # Trim whitespace at beginning and end.
 }

 # Look for the email addresses listed in an OWNERS file. Return the addresses as
 # a comma-separated string.
 function parse_owners_file_for_owners() {
   local file=$1

   grep -E -o "^\s*\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,6}\b" "${file}" | # Find email addresses at line starts.
     tr -d ' ' |                                                                    # Remove spaces.
     xargs -n 1 |                                                                   # Trim whitespace at beginning and end.
     sort | uniq |                                                                  # Remove duplicates.
     paste -sd "," -                                                                # Recombine into a comma-separated list.
 }

 # Look for "<token> <command> = <address> [, <address>]*" lines in OWNERS files
 # and return the addresses. The token is a regular expression expected at the
 # start of a line. Example tokens include "per-file" and
 # "#[[:space:]]*per-file-COMPONENT". The addresses are not checked for format
 # so may contain a `file: <filename>`.
 function parse_owners_file_for_per_file() {
   local file=$1
   local token=$2
   local cmd_name=$3

   # Note that there can be multiple per-file entries for a command. The sequence
   # below will include and combine them.
   grep -E "^${token}[ \:]+" "${file}" |                 # Find lines with the token followed by a space or colon.
     grep -E "[, ]+(${cmd_name}|${cmd_name}.fx)[, =]+" | # Find the command as a whole word (+/- '.fx') only.
     grep -E "(${cmd_name}|${cmd_name}.fx).*=" |         # Only lines with the cmd (+/- '.fx') *followed* by =.
     cut -d"=" -f2 |                                     # Use only the part after the =.
     cut -d"#" -f1 |                                     # Strip any additional comments.
     tr -d ' ' |                                         # Remove spaces.
     tr ',' '\n' |                                       # Split into separate lines.
     xargs -n 1 |                                        # Trim whitespace at beginning and end.
     sort | uniq |                                       # Remove duplicates.
     paste -sd "," -                                     # Recombine into a comma-separated list.
 }

 # Look for "# COMPONENT: <component> [, <component>]*" lines in OWNERS files and
 # return the components.
 function parse_owners_file_for_COMPONENTS() {
   local file=$1

   # Note that there could be multiple entries. The sequence below will include
   # and combine them.
   grep -E "^#[[:space:]]*COMPONENT[ \:]+" "${file}" | # Find lines with the token followed by a space or colon.
     cut -d":" -f2 |                                   # Use only the part after the :.
     cut -d"#" -f1 |                                   # Strip any additional comments.
     tr -d ' ' |                                       # Remove spaces.
     tr ',' '\n' |                                     # Split into separate lines.
     xargs -n 1 |                                      # Trim whitespace at beginning and end.
     sort | uniq |                                     # Remove duplicates.
     paste -sd "," -                                   # Recombine into a comma-separated list.
 }

 rawurlencode() {
   local string=$1
   local strlen=${#string}
   local encoded=""
   local pos c o

   for ((pos = 0; pos < strlen; pos++)); do
     c=${string:$pos:1}
     case "$c" in [-_.~a-zA-Z0-9]) o="${c}" ;;
     *) printf -v o '%%%02x' "'$c" ;;
     esac
     encoded+="${o}"
   done
   echo "${encoded}"
 }

 # Given a command and arguments, file a bug in the given component and cc the
 # given owners.
 function file_bug() {
   local cmd_name=$1
   local cmd_args=$2
   local component=$3
   local owners=$4 # comma-separated string

   local base_url="https://bugs.fuchsia.dev/p/fuchsia/issues/entry"

   local summary_escd
   summary_escd=$(rawurlencode "[fx ${cmd_name}] one-line summary")

   local description="The following issue was found with the \`fx ${cmd_name}\` command"

   if [[ -n "${cmd_args}" ]]; then
     description="${description} when run as follows:

     $ fx ${cmd_name} ${cmd_args}"
   else
     description="${description}."
   fi

   description="${description}

 Steps to complete this bug report:
   1. Correct the one-line summary above.
   2. Describe the issue.
   3. Provide the steps to reproduce the issue.

 [This bug report was generated using \`fx report-bug <cmd> <args>\` and
 modified by the reporter. If you are listed in the initial Cc: list,
 please add or update the \`per-file-COMPONENT\` line in the OWNERS file
 to ensure bugs are filed to the correct component.]
 "
   description_escd=$(rawurlencode "${description}")

   local url
   url="${base_url}?summary=${summary_escd}&description=${description_escd}"

   if [[ -n "$component" ]]; then
     url="${url}&components=$(rawurlencode "$component")"
   fi

   # Put the file owners in the "Cc:" field.
   if [[ -n "$owners" ]]; then
     url="${url}&cc=$(rawurlencode "$owners")"
   fi

   fx-info "Use the following URL to report your issue. [Hint: Try control-clicking or command-clicking to make the URL clickable.]"
   fx-info "${url}"
 }

 # Find a bugs.fuchsia.dev component or command owners in a given OWNERS file.
 # Return 0 if found else 1 if the search should continue.
 #
 # This is a recursive algorithm that follows `file:` directives in `per-file`
 # and `per-file_COMPONENT` lines. To keep it understandable, it works simply: It
 # recurses one-way on one path, carrying the parent call's variables as globals.
 # When sufficient owners and component data is found, a bug is created and
 # written to stdout. It stops as soon as it has sufficient data, thus keeping
 # the data as close to the given command as possible.
 #
 # The algorithm prefers `file:` directives over includes and will not trace both
 # `file:` and `include` directives in the same file. This is usually correct
 # because `file:` directives override `include` directives. It will traverse
 # multiple `file:` directives if they occur in both per-file and
 # per-file-COMPONENT lines.
 function check_an_owners_file() {
   local cmd_name=$1
   local cmd_args=$2
   local file=$3

   if [[ ! -f "${file}" ]]; then
     return 1
   fi

   "${verbose}" && echo "looking for a component and owners in ${file}"

   # 1. The list of email addresses in the file.
   local new_listed_owners
   new_listed_owners=$(parse_owners_file_for_owners "${file}")
   # Note that here and below, the global value is used if one is not found
   # locally.
   local listed_owners="${new_listed_owners:-$listed_owners}"
   [[ -n "${listed_owners}" ]] && "${verbose}" && echo "found owners: ${listed_owners}"

   # 2. `# COMPONENT: <string>` line in the OWNERS file.
   local new_component_in_owners_file
   new_component_in_owners_file=$(parse_owners_file_for_COMPONENTS "${file}")
   local component_in_owners_file="${new_component_in_owners_file:-$component_in_owners_file}"
   [[ -n "${component_in_owners_file}" ]] && "${verbose}" && echo "found components: ${component_in_owners_file}"

   # 3.  `per-file-COMPONENT` line.
   local new_per_file_component
   new_per_file_component=$(parse_owners_file_for_per_file "${file}" "#[[:space:]]*per-file-COMPONENT" "${cmd_name}")
   local per_file_component="${per_file_component:-$new_per_file_component}"
   [[ -n "${per_file_component}" ]] && "${verbose}" && echo "found per_file components: ${per_file_component}"

   # 4. `per-file` owners line.
   local new_per_file_owners
   new_per_file_owners=$(parse_owners_file_for_per_file "${file}" "per-file" "${cmd_name}")
   if [[ -n "${new_per_file_owners}" ]]; then
     listed_owners=""
   fi
   local per_file_owners="${per_file_owners:-$new_per_file_owners}"

   # If there's a per-file `file:` directive, follow it, carrying the above
   # values into the call as global variables.
   if [[ "${per_file_owners}" =~ ^\s*file\s*:.* ]]; then
     local next_file=${FUCHSIA_DIR}${per_file_owners#"file:"}
     "${verbose}" && echo "per-file file to search: ${next_file}"
     per_file_owners="" # clear so it isn't re-expanded
     if check_an_owners_file "${cmd_name}" "${cmd_args}" "${next_file}"; then
       return 0 # Success.
     fi
   fi

   # Prefer the per_file_owners over any listed owners.
   local owners="${per_file_owners:-${listed_owners}}"

   # If we don't have any owners, then follow include files, carrying the above
   # values into the call as global variables.
   local include_file
   include_file=$(parse_owners_file_for_includes "${file}")
   # We prefer the owner listed directly in a file over those in a remote
   # included directory. This preference ensures that we don't accummulate whole
   # team lists as we recurse farther and farther from the fx command files.
   if [[ -n "${include_file}" ]] && [[ -z "${listed_owners}" ]]; then
     "${verbose}" && echo "found an 'include' directive': ${include_file}"
     fullpath="${FUCHSIA_DIR}${include_file}"
     if check_an_owners_file "${cmd_name}" "${cmd_args}" "${fullpath}"; then
       return 0 # Success.
     fi
   fi

   # Found enough to file a bug. As the component may have come from several
   # sources, the preferred order is:
   # per_file_component > component_in_owners_file > DEFAULT_COMPONENT.
   local component="${per_file_component:-${component_in_owners_file}}"
   component="${component:-${DEFAULT_COMPONENT}}"

   file_bug "${cmd_name}" "${cmd_args}" "${component}" "${owners}"
   return 0
 }

 # Climb the command's filepath, checking OWNERS files, looking for "per-file"
 # owners or COMPONENT lines. File a bug when either is found.
 function parse_owners_files() {
   local cmd_name=$1
   local cmd_args=$2
   local cmd_path=$3

   local parent
   parent="${cmd_path%/*}"
   while [[ -n "${parent}" ]] && [[ "${parent}" != "${FUCHSIA_DIR}" ]]; do
     if check_an_owners_file "${cmd_name}" "${cmd_args}" "${parent}/OWNERS"; then
       return 0 # Success.
     fi
     parent="${parent%/*}"
   done

   # Nothing found; file against the default component.
   file_bug "${cmd_name}" "${cmd_args}" "${DEFAULT_COMPONENT}"
 }

 function analyze_command_and_report_issue() {
   local cmd_name=$1
   local cmd_args=$2

   local cmd_path
   cmd_path="$(commands "${cmd_name}" | head -1)"
   if [[ -z "${cmd_path}" ]]; then
     fx-error "cannot find command: ${cmd_name}"
     exit 1
   fi

   parse_owners_files "${cmd_name}" "${cmd_args}" "${cmd_path}"
 }

 function main() {
   [[ $# == 0 ]] && fx-command-help && exit 0

   while [[ $# -ne 0 ]]; do
     case $1 in
     -h | --help | "")
       fx-command-help
       exit 0
       ;;
     -v | --verbose)
       verbose=true
       shift
       ;;
     -*)
       fx-error "Unknown argument $1"
       fx-command-help
       exit 1
       ;;
     *)
       break
       ;;
     esac
   done
   local cmd_name=$1
   shift
   local cmd_args="$*"

   if [[ -z "${cmd_name}" ]]; then
     fx-error "error parsing command name"
     exit 1
   fi

   analyze_command_and_report_issue "${cmd_name}" "${cmd_args}"
 }

 main "$@"
	#!/bin/bash
	# Copyright 2021 The Fuchsia Authors. All rights reserved.
	# Use of this source code is governed by a BSD-style license that can be
	# found in the LICENSE file.

	#### CATEGORY=Software delivery
	### report a bug for an fx command
	## usage:
	## fx report-bug [<flags>] <command> [<args>]
	## Report an issue on an fx <command>.
	##
	## <flags>: [optional] include:
	## -v, --verbose: verbose output
	## -h, --help : provide this help.
	##
	## <command>: any fx command.
	##
	## <args>: [optional] the arguments passed to the fx <command> that
	## caused the issue being reported, for inclusion in the bug
	## report.
	##
	## This tool will help file a bug on bugs.fuchsia.dev for the given command. It
	## parses the COMPONENT and OWNERS lines of the command's metadata or, if those
	## aren't present, the `per-file` and `# COMPONENT:` lines of their OWNERS
	## files. This parsing allows `report-bug` to specify which bugs.fuchsia.dev
	## component the bug should be filed in and who should be added to the "Cc:"
	## field.
	##
	## `fx report-bug` will print out a URL that can be pasted into a browser to
	## create a bug with the appropriate fields pre-filled. Just add the details
	## and submit it.
	##
	## Be sure to include the <args> so the the bug report can show the exact
	## command invocation that exhibited the reported issue.

	set -e

	# Globals
	readonly DEFAULT_COMPONENT="Tools>fx"
	verbose=false

	# shellcheck source=/dev/null
	source "$(cd "$(dirname "${BASH_SOURCE[0]}")" >/dev/null 2>&1 && pwd)"/lib/vars.sh \|\| exit $?
	fx-config-read

	# Look for an `include <filename>` line in an OWNERS file. Return the filename.
	function parse_owners_file_for_includes() {
	local file=$1

	grep -E "^include " "${file}" \| # Find lines with the token followed by a space or colon.
	cut -d" " -f2 \| # Use only the part after the =.
	cut -d"#" -f1 \| # Strip any additional comments.
	xargs -n 1 # Trim whitespace at beginning and end.
	}

	# Look for the email addresses listed in an OWNERS file. Return the addresses as
	# a comma-separated string.
	function parse_owners_file_for_owners() {
	local file=$1

	grep -E -o "^\s*\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,6}\b" "${file}" \| # Find email addresses at line starts.
	tr -d ' ' \| # Remove spaces.
	xargs -n 1 \| # Trim whitespace at beginning and end.
	sort \| uniq \| # Remove duplicates.
	paste -sd "," - # Recombine into a comma-separated list.
	}

	# Look for "<token> <command> = <address> [, <address>]*" lines in OWNERS files
	# and return the addresses. The token is a regular expression expected at the
	# start of a line. Example tokens include "per-file" and
	# "#[[:space:]]*per-file-COMPONENT". The addresses are not checked for format
	# so may contain a `file: <filename>`.
	function parse_owners_file_for_per_file() {
	local file=$1
	local token=$2
	local cmd_name=$3

	# Note that there can be multiple per-file entries for a command. The sequence
	# below will include and combine them.
	grep -E "^${token}[ \:]+" "${file}" \| # Find lines with the token followed by a space or colon.
	grep -E "[, ]+(${cmd_name}\|${cmd_name}.fx)[, =]+" \| # Find the command as a whole word (+/- '.fx') only.
	grep -E "(${cmd_name}\|${cmd_name}.fx).=" \| # Only lines with the cmd (+/- '.fx') followed* by =.
	cut -d"=" -f2 \| # Use only the part after the =.
	cut -d"#" -f1 \| # Strip any additional comments.
	tr -d ' ' \| # Remove spaces.
	tr ',' '\n' \| # Split into separate lines.
	xargs -n 1 \| # Trim whitespace at beginning and end.
	sort \| uniq \| # Remove duplicates.
	paste -sd "," - # Recombine into a comma-separated list.
	}

	# Look for "# COMPONENT: <component> [, <component>]*" lines in OWNERS files and
	# return the components.
	function parse_owners_file_for_COMPONENTS() {
	local file=$1

	# Note that there could be multiple entries. The sequence below will include
	# and combine them.
	grep -E "^#[[:space:]]*COMPONENT[ \:]+" "${file}" \| # Find lines with the token followed by a space or colon.
	cut -d":" -f2 \| # Use only the part after the :.
	cut -d"#" -f1 \| # Strip any additional comments.
	tr -d ' ' \| # Remove spaces.
	tr ',' '\n' \| # Split into separate lines.
	xargs -n 1 \| # Trim whitespace at beginning and end.
	sort \| uniq \| # Remove duplicates.
	paste -sd "," - # Recombine into a comma-separated list.
	}

	rawurlencode() {
	local string=$1
	local strlen=${#string}
	local encoded=""
	local pos c o

	for ((pos = 0; pos < strlen; pos++)); do
	c=${string:$pos:1}
	case "$c" in [-_.~a-zA-Z0-9]) o="${c}" ;;
	*) printf -v o '%%%02x' "'$c" ;;
	esac
	encoded+="${o}"
	done
	echo "${encoded}"
	}

	# Given a command and arguments, file a bug in the given component and cc the
	# given owners.
	function file_bug() {
	local cmd_name=$1
	local cmd_args=$2
	local component=$3
	local owners=$4 # comma-separated string

	local base_url="https://bugs.fuchsia.dev/p/fuchsia/issues/entry"

	local summary_escd
	summary_escd=$(rawurlencode "[fx ${cmd_name}] one-line summary")

	local description="The following issue was found with the \`fx ${cmd_name}\` command"

	if [[ -n "${cmd_args}" ]]; then
	description="${description} when run as follows:

	$ fx ${cmd_name} ${cmd_args}"
	else
	description="${description}."
	fi

	description="${description}

	Steps to complete this bug report:
	1. Correct the one-line summary above.
	2. Describe the issue.
	3. Provide the steps to reproduce the issue.

	[This bug report was generated using \`fx report-bug <cmd> <args>\` and
	modified by the reporter. If you are listed in the initial Cc: list,
	please add or update the \`per-file-COMPONENT\` line in the OWNERS file
	to ensure bugs are filed to the correct component.]
	"
	description_escd=$(rawurlencode "${description}")

	local url
	url="${base_url}?summary=${summary_escd}&description=${description_escd}"

	if [[ -n "$component" ]]; then
	url="${url}&components=$(rawurlencode "$component")"
	fi

	# Put the file owners in the "Cc:" field.
	if [[ -n "$owners" ]]; then
	url="${url}&cc=$(rawurlencode "$owners")"
	fi

	fx-info "Use the following URL to report your issue. [Hint: Try control-clicking or command-clicking to make the URL clickable.]"
	fx-info "${url}"
	}

	# Find a bugs.fuchsia.dev component or command owners in a given OWNERS file.
	# Return 0 if found else 1 if the search should continue.
	#
	# This is a recursive algorithm that follows `file:` directives in `per-file`
	# and `per-file_COMPONENT` lines. To keep it understandable, it works simply: It
	# recurses one-way on one path, carrying the parent call's variables as globals.
	# When sufficient owners and component data is found, a bug is created and
	# written to stdout. It stops as soon as it has sufficient data, thus keeping
	# the data as close to the given command as possible.
	#
	# The algorithm prefers `file:` directives over includes and will not trace both
	# `file:` and `include` directives in the same file. This is usually correct
	# because `file:` directives override `include` directives. It will traverse
	# multiple `file:` directives if they occur in both per-file and
	# per-file-COMPONENT lines.
	function check_an_owners_file() {
	local cmd_name=$1
	local cmd_args=$2
	local file=$3

	if [[ ! -f "${file}" ]]; then
	return 1
	fi

	"${verbose}" && echo "looking for a component and owners in ${file}"

	# 1. The list of email addresses in the file.
	local new_listed_owners
	new_listed_owners=$(parse_owners_file_for_owners "${file}")
	# Note that here and below, the global value is used if one is not found
	# locally.
	local listed_owners="${new_listed_owners:-$listed_owners}"
	[[ -n "${listed_owners}" ]] && "${verbose}" && echo "found owners: ${listed_owners}"

	# 2. `# COMPONENT: <string>` line in the OWNERS file.
	local new_component_in_owners_file
	new_component_in_owners_file=$(parse_owners_file_for_COMPONENTS "${file}")
	local component_in_owners_file="${new_component_in_owners_file:-$component_in_owners_file}"
	[[ -n "${component_in_owners_file}" ]] && "${verbose}" && echo "found components: ${component_in_owners_file}"

	# 3. `per-file-COMPONENT` line.
	local new_per_file_component
	new_per_file_component=$(parse_owners_file_for_per_file "${file}" "#[[:space:]]*per-file-COMPONENT" "${cmd_name}")
	local per_file_component="${per_file_component:-$new_per_file_component}"
	[[ -n "${per_file_component}" ]] && "${verbose}" && echo "found per_file components: ${per_file_component}"

	# 4. `per-file` owners line.
	local new_per_file_owners
	new_per_file_owners=$(parse_owners_file_for_per_file "${file}" "per-file" "${cmd_name}")
	if [[ -n "${new_per_file_owners}" ]]; then
	listed_owners=""
	fi
	local per_file_owners="${per_file_owners:-$new_per_file_owners}"

	# If there's a per-file `file:` directive, follow it, carrying the above
	# values into the call as global variables.
	if [[ "${per_file_owners}" =~ ^\sfile\s:.* ]]; then
	local next_file=${FUCHSIA_DIR}${per_file_owners#"file:"}
	"${verbose}" && echo "per-file file to search: ${next_file}"
	per_file_owners="" # clear so it isn't re-expanded
	if check_an_owners_file "${cmd_name}" "${cmd_args}" "${next_file}"; then
	return 0 # Success.
	fi
	fi

	# Prefer the per_file_owners over any listed owners.
	local owners="${per_file_owners:-${listed_owners}}"

	# If we don't have any owners, then follow include files, carrying the above
	# values into the call as global variables.
	local include_file
	include_file=$(parse_owners_file_for_includes "${file}")
	# We prefer the owner listed directly in a file over those in a remote
	# included directory. This preference ensures that we don't accummulate whole
	# team lists as we recurse farther and farther from the fx command files.
	if [[ -n "${include_file}" ]] && [[ -z "${listed_owners}" ]]; then
	"${verbose}" && echo "found an 'include' directive': ${include_file}"
	fullpath="${FUCHSIA_DIR}${include_file}"
	if check_an_owners_file "${cmd_name}" "${cmd_args}" "${fullpath}"; then
	return 0 # Success.
	fi
	fi

	# Found enough to file a bug. As the component may have come from several
	# sources, the preferred order is:
	# per_file_component > component_in_owners_file > DEFAULT_COMPONENT.
	local component="${per_file_component:-${component_in_owners_file}}"
	component="${component:-${DEFAULT_COMPONENT}}"

	file_bug "${cmd_name}" "${cmd_args}" "${component}" "${owners}"
	return 0
	}

	# Climb the command's filepath, checking OWNERS files, looking for "per-file"
	# owners or COMPONENT lines. File a bug when either is found.
	function parse_owners_files() {
	local cmd_name=$1
	local cmd_args=$2
	local cmd_path=$3

	local parent
	parent="${cmd_path%/*}"
	while [[ -n "${parent}" ]] && [[ "${parent}" != "${FUCHSIA_DIR}" ]]; do
	if check_an_owners_file "${cmd_name}" "${cmd_args}" "${parent}/OWNERS"; then
	return 0 # Success.
	fi
	parent="${parent%/*}"
	done

	# Nothing found; file against the default component.
	file_bug "${cmd_name}" "${cmd_args}" "${DEFAULT_COMPONENT}"
	}

	function analyze_command_and_report_issue() {
	local cmd_name=$1
	local cmd_args=$2

	local cmd_path
	cmd_path="$(commands "${cmd_name}" \| head -1)"
	if [[ -z "${cmd_path}" ]]; then
	fx-error "cannot find command: ${cmd_name}"
	exit 1
	fi

	parse_owners_files "${cmd_name}" "${cmd_args}" "${cmd_path}"
	}

	function main() {
	[[ $# == 0 ]] && fx-command-help && exit 0

	while [[ $# -ne 0 ]]; do
	case $1 in
	-h \| --help \| "")
	fx-command-help
	exit 0
	;;
	-v \| --verbose)
	verbose=true
	shift
	;;
	-*)
	fx-error "Unknown argument $1"
	fx-command-help
	exit 1
	;;
	*)
	break
	;;
	esac
	done
	local cmd_name=$1
	shift
	local cmd_args="$*"

	if [[ -z "${cmd_name}" ]]; then
	fx-error "error parsing command name"
	exit 1
	fi

	analyze_command_and_report_issue "${cmd_name}" "${cmd_args}"
	}

	main "$@"