make updates due to linter update

Signed-off-by: Alex Goodman <alex.goodman@anchore.com>
update golangci + add additional lint rules
2026-10-12 14:17:20 +02:00 · 2021-10-05 22:51:36 -04:00 · 2021-10-05 22:50:57 -04:00
373 changed files with 4081 additions and 12472 deletions
@@ -15,8 +15,3 @@ ignore-packages:
  # * GNU General Public License, version 2.0 or later (GPL-2.0-or-later).
  # (we choose Apache-2.0)
  - github.com/spdx/tools-golang
-
-  # from: https://github.com/xi2/xz/blob/master/LICENSE
-  # All these files have been put into the public domain.
-  # You can do whatever you want with these files.
-  - github.com/xi2/xz
@@ -1,398 +0,0 @@
-#!/bin/sh
-set -e
-# Code generated by godownloader on 2019-12-25T12:47:14Z. DO NOT EDIT.
-#
-
-usage() {
-	this=$1
-	cat <<EOF
-$this: download go binaries for goreleaser/goreleaser
-
-Usage: $this [-b] bindir [-d] [tag]
-  -b sets bindir or installation directory, Defaults to ./bin
-  -d turns on debug logging
-   [tag] is a tag from
-   https://github.com/goreleaser/goreleaser/releases
-   If tag is missing, then the latest will be used.
-
- Generated by godownloader
-  https://github.com/goreleaser/godownloader
-
-EOF
-	exit 2
-}
-
-parse_args() {
-	#BINDIR is ./bin unless set be ENV
-	# over-ridden by flag below
-
-	BINDIR=${BINDIR:-./bin}
-	while getopts "b:dh?x" arg; do
-		case "$arg" in
-		b) BINDIR="$OPTARG" ;;
-		d) log_set_priority 10 ;;
-		h | \?) usage "$0" ;;
-		x) set -x ;;
-		esac
-	done
-	shift $((OPTIND - 1))
-	TAG=$1
-}
-# this function wraps all the destructive operations
-# if a curl|bash cuts off the end of the script due to
-# network, either nothing will happen or will syntax error
-# out preventing half-done work
-execute() {
-	tmpdir=$(mktemp -d)
-	log_debug "downloading files into ${tmpdir}"
-	http_download "${tmpdir}/${TARBALL}" "${TARBALL_URL}"
-	http_download "${tmpdir}/${CHECKSUM}" "${CHECKSUM_URL}"
-	hash_sha256_verify "${tmpdir}/${TARBALL}" "${tmpdir}/${CHECKSUM}"
-	srcdir="${tmpdir}"
-	(cd "${tmpdir}" && untar "${TARBALL}")
-	test ! -d "${BINDIR}" && install -d "${BINDIR}"
-	for binexe in $BINARIES; do
-		if [ "$OS" = "windows" ]; then
-			binexe="${binexe}.exe"
-		fi
-		install "${srcdir}/${binexe}" "${BINDIR}/"
-		log_info "installed ${BINDIR}/${binexe}"
-	done
-	rm -rf "${tmpdir}"
-}
-get_binaries() {
-	case "$PLATFORM" in
-	darwin/386) BINARIES="goreleaser" ;;
-	darwin/amd64) BINARIES="goreleaser" ;;
-	darwin/arm64) BINARIES="goreleaser" ;;
-	darwin/armv6) BINARIES="goreleaser" ;;
-	linux/386) BINARIES="goreleaser" ;;
-	linux/amd64) BINARIES="goreleaser" ;;
-	linux/arm64) BINARIES="goreleaser" ;;
-	linux/armv6) BINARIES="goreleaser" ;;
-	windows/386) BINARIES="goreleaser" ;;
-	windows/amd64) BINARIES="goreleaser" ;;
-	windows/arm64) BINARIES="goreleaser" ;;
-	windows/armv6) BINARIES="goreleaser" ;;
-	*)
-		log_crit "platform $PLATFORM is not supported.  Make sure this script is up-to-date and file request at https://github.com/${PREFIX}/issues/new"
-		exit 1
-		;;
-	esac
-}
-tag_to_version() {
-	if [ -z "${TAG}" ]; then
-		log_info "checking GitHub for latest tag"
-	else
-		log_info "checking GitHub for tag '${TAG}'"
-	fi
-	REALTAG=$(github_release "$OWNER/$REPO" "${TAG}") && true
-	if test -z "$REALTAG"; then
-		log_crit "unable to find '${TAG}' - use 'latest' or see https://github.com/${PREFIX}/releases for details"
-		exit 1
-	fi
-	# if version starts with 'v', remove it
-	TAG="$REALTAG"
-	VERSION=${TAG#v}
-}
-adjust_format() {
-	# change format (tar.gz or zip) based on OS
-	case ${OS} in
-	windows) FORMAT=zip ;;
-	esac
-	true
-}
-adjust_os() {
-	# adjust archive name based on OS
-	case ${OS} in
-	386) OS=i386 ;;
-	amd64) OS=x86_64 ;;
-	darwin) OS=Darwin ;;
-	linux) OS=Linux ;;
-	windows) OS=Windows ;;
-	esac
-	true
-}
-adjust_arch() {
-	# adjust archive name based on ARCH
-	case ${ARCH} in
-	386) ARCH=i386 ;;
-	amd64) ARCH=x86_64 ;;
-	darwin) ARCH=Darwin ;;
-	linux) ARCH=Linux ;;
-	windows) ARCH=Windows ;;
-	esac
-	true
-}
-
-cat /dev/null <<EOF
------------------------------------------------------------------------
-https://github.com/client9/shlib - portable posix shell functions
-Public domain - http://unlicense.org
-https://github.com/client9/shlib/blob/master/LICENSE.md
-but credit (and pull requests) appreciated.
------------------------------------------------------------------------
-EOF
-is_command() {
-	command -v "$1" >/dev/null
-}
-echoerr() {
-	echo "$@" 1>&2
-}
-log_prefix() {
-	echo "$0"
-}
-_logp=6
-log_set_priority() {
-	_logp="$1"
-}
-log_priority() {
-	if test -z "$1"; then
-		echo "$_logp"
-		return
-	fi
-	[ "$1" -le "$_logp" ]
-}
-log_tag() {
-	case $1 in
-	0) echo "emerg" ;;
-	1) echo "alert" ;;
-	2) echo "crit" ;;
-	3) echo "err" ;;
-	4) echo "warning" ;;
-	5) echo "notice" ;;
-	6) echo "info" ;;
-	7) echo "debug" ;;
-	*) echo "$1" ;;
-	esac
-}
-log_debug() {
-	log_priority 7 || return 0
-	echoerr "$(log_prefix)" "$(log_tag 7)" "$@"
-}
-log_info() {
-	log_priority 6 || return 0
-	echoerr "$(log_prefix)" "$(log_tag 6)" "$@"
-}
-log_err() {
-	log_priority 3 || return 0
-	echoerr "$(log_prefix)" "$(log_tag 3)" "$@"
-}
-log_crit() {
-	log_priority 2 || return 0
-	echoerr "$(log_prefix)" "$(log_tag 2)" "$@"
-}
-uname_os() {
-	os=$(uname -s | tr '[:upper:]' '[:lower:]')
-	case "$os" in
-	cygwin_nt*) os="windows" ;;
-	mingw*) os="windows" ;;
-	msys_nt*) os="windows" ;;
-	esac
-	echo "$os"
-}
-uname_arch() {
-	arch=$(uname -m)
-	case $arch in
-	x86_64) arch="amd64" ;;
-	x86) arch="386" ;;
-	i686) arch="386" ;;
-	i386) arch="386" ;;
-	aarch64) arch="arm64" ;;
-	armv5*) arch="armv5" ;;
-	armv6*) arch="armv6" ;;
-	armv7*) arch="armv7" ;;
-	esac
-	echo ${arch}
-}
-uname_os_check() {
-	os=$(uname_os)
-	case "$os" in
-	darwin) return 0 ;;
-	dragonfly) return 0 ;;
-	freebsd) return 0 ;;
-	linux) return 0 ;;
-	android) return 0 ;;
-	nacl) return 0 ;;
-	netbsd) return 0 ;;
-	openbsd) return 0 ;;
-	plan9) return 0 ;;
-	solaris) return 0 ;;
-	windows) return 0 ;;
-	esac
-	log_crit "uname_os_check '$(uname -s)' got converted to '$os' which is not a GOOS value. Please file bug at https://github.com/client9/shlib"
-	return 1
-}
-uname_arch_check() {
-	arch=$(uname_arch)
-	case "$arch" in
-	386) return 0 ;;
-	amd64) return 0 ;;
-	arm64) return 0 ;;
-	armv5) return 0 ;;
-	armv6) return 0 ;;
-	armv7) return 0 ;;
-	ppc64) return 0 ;;
-	ppc64le) return 0 ;;
-	mips) return 0 ;;
-	mipsle) return 0 ;;
-	mips64) return 0 ;;
-	mips64le) return 0 ;;
-	s390x) return 0 ;;
-	amd64p32) return 0 ;;
-	esac
-	log_crit "uname_arch_check '$(uname -m)' got converted to '$arch' which is not a GOARCH value.  Please file bug report at https://github.com/client9/shlib"
-	return 1
-}
-untar() {
-	tarball=$1
-	case "${tarball}" in
-	*.tar.gz | *.tgz) tar --no-same-owner -xzf "${tarball}" ;;
-	*.tar) tar --no-same-owner -xf "${tarball}" ;;
-	*.zip) unzip "${tarball}" ;;
-	*)
-		log_err "untar unknown archive format for ${tarball}"
-		return 1
-		;;
-	esac
-}
-http_download_curl() {
-	local_file=$1
-	source_url=$2
-	header=$3
-	if [ -z "$header" ]; then
-		code=$(curl -w '%{http_code}' -sL -o "$local_file" "$source_url")
-	else
-		code=$(curl -w '%{http_code}' -sL -H "$header" -o "$local_file" "$source_url")
-	fi
-	if [ "$code" != "200" ]; then
-		log_debug "http_download_curl received HTTP status $code"
-		return 1
-	fi
-	return 0
-}
-http_download_wget() {
-	local_file=$1
-	source_url=$2
-	header=$3
-	if [ -z "$header" ]; then
-		wget -q -O "$local_file" "$source_url"
-	else
-		wget -q --header "$header" -O "$local_file" "$source_url"
-	fi
-}
-http_download() {
-	log_debug "http_download $2"
-	if is_command curl; then
-		http_download_curl "$@"
-		return
-	elif is_command wget; then
-		http_download_wget "$@"
-		return
-	fi
-	log_crit "http_download unable to find wget or curl"
-	return 1
-}
-http_copy() {
-	tmp=$(mktemp)
-	http_download "${tmp}" "$1" "$2" || return 1
-	body=$(cat "$tmp")
-	rm -f "${tmp}"
-	echo "$body"
-}
-github_release() {
-	owner_repo=$1
-	version=$2
-	test -z "$version" && version="latest"
-	giturl="https://github.com/${owner_repo}/releases/${version}"
-	json=$(http_copy "$giturl" "Accept:application/json")
-	test -z "$json" && return 1
-	version=$(echo "$json" | tr -s '\n' ' ' | sed 's/.*"tag_name":"//' | sed 's/".*//')
-	test -z "$version" && return 1
-	echo "$version"
-}
-hash_sha256() {
-	TARGET=${1:-/dev/stdin}
-	if is_command gsha256sum; then
-		hash=$(gsha256sum "$TARGET") || return 1
-		echo "$hash" | cut -d ' ' -f 1
-	elif is_command sha256sum; then
-		hash=$(sha256sum "$TARGET") || return 1
-		echo "$hash" | cut -d ' ' -f 1
-	elif is_command shasum; then
-		hash=$(shasum -a 256 "$TARGET" 2>/dev/null) || return 1
-		echo "$hash" | cut -d ' ' -f 1
-	elif is_command openssl; then
-		hash=$(openssl -dst openssl dgst -sha256 "$TARGET") || return 1
-		echo "$hash" | cut -d ' ' -f a
-	else
-		log_crit "hash_sha256 unable to find command to compute sha-256 hash"
-		return 1
-	fi
-}
-hash_sha256_verify() {
-	TARGET=$1
-	checksums=$2
-	if [ -z "$checksums" ]; then
-		log_err "hash_sha256_verify checksum file not specified in arg2"
-		return 1
-	fi
-	BASENAME=${TARGET##*/}
-	want=$(grep "${BASENAME}" "${checksums}" 2>/dev/null | tr '\t' ' ' | cut -d ' ' -f 1)
-	if [ -z "$want" ]; then
-		log_err "hash_sha256_verify unable to find checksum for '${TARGET}' in '${checksums}'"
-		return 1
-	fi
-	got=$(hash_sha256 "$TARGET")
-	if [ "$want" != "$got" ]; then
-		log_err "hash_sha256_verify checksum for '$TARGET' did not verify ${want} vs $got"
-		return 1
-	fi
-}
-cat /dev/null <<EOF
------------------------------------------------------------------------
-End of functions from https://github.com/client9/shlib
------------------------------------------------------------------------
-EOF
-
-PROJECT_NAME="goreleaser"
-OWNER=goreleaser
-REPO="goreleaser"
-BINARY=goreleaser
-FORMAT=tar.gz
-OS=$(uname_os)
-ARCH=$(uname_arch)
-PREFIX="$OWNER/$REPO"
-
-# use in logging routines
-log_prefix() {
-	echo "$PREFIX"
-}
-PLATFORM="${OS}/${ARCH}"
-GITHUB_DOWNLOAD=https://github.com/${OWNER}/${REPO}/releases/download
-
-uname_os_check "$OS"
-uname_arch_check "$ARCH"
-
-parse_args "$@"
-
-get_binaries
-
-tag_to_version
-
-adjust_format
-
-adjust_os
-
-adjust_arch
-
-log_info "found version: ${VERSION} for ${TAG}/${OS}/${ARCH}"
-
-NAME=${PROJECT_NAME}_${OS}_${ARCH}
-TARBALL=${NAME}.${FORMAT}
-TARBALL_URL=${GITHUB_DOWNLOAD}/${TAG}/${TARBALL}
-CHECKSUM=checksums.txt
-CHECKSUM_URL=${GITHUB_DOWNLOAD}/${TAG}/${CHECKSUM}
-
-execute
-log_err "this script is deprecated, please do not use it anymore. check https://github.com/goreleaser/godownloader/issues/207"
@@ -31,6 +31,15 @@ jobs:
    steps:
    - name: Checkout repository
      uses: actions/checkout@v2
+      with:
+        # We must fetch at least the immediate parents so that if this is
+        # a pull request then we can checkout the head.
+        fetch-depth: 2
+
+    # If this run was triggered by a pull request event, then checkout
+    # the head of the pull request instead of the merge commit.
+    - run: git checkout HEAD^2
+      if: ${{ github.event_name == 'pull_request' }}

    # Initializes the CodeQL tools for scanning.
    - name: Initialize CodeQL
@@ -96,6 +96,10 @@ jobs:
    steps:
      - uses: docker-practice/actions-setup-docker@v1

+      # note, it is important to always be auth'd into docker.io to prevent rate limiting issues
+      - name: Login to Docker Hub
+        run: echo ${{ secrets.TOOLBOX_DOCKER_PASS }} | docker login docker.io -u ${{ secrets.TOOLBOX_DOCKER_USER }} --password-stdin
+
      - uses: actions/setup-go@v2
        with:
          go-version: ${{ env.GO_VERSION }}
@@ -232,9 +232,6 @@ jobs:

      - uses: actions/checkout@v2

-      - name: Set up QEMU
-        uses: docker/setup-qemu-action@v1
-
      - name: Restore tool cache
        id: tool-cache
        uses: actions/cache@v2.1.3
@@ -308,10 +305,6 @@ jobs:
    needs: [Build-Snapshot-Artifacts]
    runs-on: ubuntu-20.04
    steps:
-      - uses: actions/setup-go@v2
-        with:
-          go-version: ${{ env.GO_VERSION }}
-
      - uses: actions/checkout@v2

      - name: Restore go cache
@@ -4,33 +4,57 @@
 #  include:
 #    - EXC0002 # disable excluding of issues about comments from golint

+linters-settings:
+
+  cyclop:
+    # the maximal code complexity to report
+    max-complexity: 15
+
 linters:
  # inverted configuration with `enable-all` and `disable` is not scalable during updates of golangci-lint
  disable-all: true
  enable:
    - asciicheck
    - bodyclose
+    - cyclop
    - deadcode
    - depguard
    - dogsled
    - dupl
+    - durationcheck
    - errcheck
+    - errname
+    - errorlint
    - exportloopref
+    - forbidigo
+    - forcetypeassert
    - funlen
+    - gci
    - gocognit
    - goconst
    - gocritic
    - gocyclo
    - gofmt
+    - gofumpt
    - goimports
+    - gomoddirectives
+    - gomodguard
    - goprintffuncname
    - gosec
    - gosimple
    - govet
+    - ifshort
+    - importas
    - ineffassign
+#    - ireturn   # will be added in 1.43.0 (accept interfaces, return structs)
+    - makezero
    - misspell
    - nakedret
+    - nilerr
+#    - nilnil   # will be added in 1.43.0
    - nolintlint
+    - paralleltest
+    - predeclared
    - revive
    - rowserrcheck
    - staticcheck
@@ -41,21 +65,29 @@ linters:
    - unparam
    - unused
    - varcheck
+    - wastedassign
    - whitespace
+#    - wrapcheck
+

 # do not enable...
+#    - exhaustive        # makes to many assumptions about enums and if a switch case should contain all enum instances
+#    - exhaustivestruct  # we like to depend on zero values
 #    - gochecknoglobals
 #    - gochecknoinits    # this is too aggressive
 #    - godot
 #    - godox
-#    - goerr113
-#    - golint      # deprecated
+#    - goerr113    # does not allow use of dynamic errors
+#    - golint      # replaced by revive
 #    - gomnd       # this is too aggressive
 #    - interfacer  # this is a good idea, but is no longer supported and is prone to false positives
 #    - lll         # without a way to specify per-line exception cases, this is not usable
 #    - maligned    # this is an excellent linter, but tricky to optimize and we are not sensitive to memory layout optimizations
-#    - nestif
+#    - nestif      # other complexity linters already cover this well
+#    - nlreturn    # no robust auto-fixers supported
+#    - noctx       # we don't use context a lot
 #    - prealloc    # following this rule isn't consistently a good idea, as it sometimes forces unnecessary allocations that result in less idiomatic code
-#    - scopelint   # deprecated
+#    - scopelint   # replaced by exportloopref
+#    - tagliatelle # too presumptive at which struct tag conventions should be used
 #    - testpackage
-#    - wsl         # this doens't have an auto-fixer yet and is pretty noisy (https://github.com/bombsimon/wsl/issues/90)
+#    - wsl         # very verbose and there is no auto-fixer for this project yet https://github.com/bombsimon/wsl/issues/90
@@ -12,10 +12,11 @@ builds:
    env:
      - CGO_ENABLED=0
    goos:
+      # windows not supported yet (due to jotframe)
+      # - windows
      - linux
    goarch:
      - amd64
-      - arm64
    # Set the modified timestamp on the output binary to the git timestamp (to ensure a reproducible build)
    mod_timestamp: '{{ .CommitTimestamp }}'
    ldflags: |
@@ -26,27 +27,7 @@ builds:
      -X github.com/anchore/syft/internal/version.gitCommit={{.Commit}}
      -X github.com/anchore/syft/internal/version.buildDate={{.Date}}
      -X github.com/anchore/syft/internal/version.gitTreeState={{.Env.BUILD_GIT_TREE_STATE}}
-
-  - binary: syft
-    id: syft-win
-    env:
-      - CGO_ENABLED=0
-    goos:
-      - windows
-    goarch:
-      - amd64
-    # Set the modified timestamp on the output binary to the git timestamp (to ensure a reproducible build)
-    mod_timestamp: '{{ .CommitTimestamp }}'
-    ldflags: |
-      -w
-      -s
-      -extldflags '-static'
-      -X github.com/anchore/syft/internal/version.version={{.Version}}
-      -X github.com/anchore/syft/internal/version.gitCommit={{.Commit}}
-      -X github.com/anchore/syft/internal/version.buildDate={{.Date}}
-      -X github.com/anchore/syft/internal/version.gitTreeState={{.Env.BUILD_GIT_TREE_STATE}}
-
-    # For more info on this macOS build, see: https://github.com/mitchellh/gon#usage-with-goreleaser
+  # For more info on this macOS build, see: https://github.com/mitchellh/gon#usage-with-goreleaser
  - binary: syft
    id: syft-macos
    env:
@@ -55,7 +36,6 @@ builds:
      - darwin
    goarch:
      - amd64
-      - arm64
    # Set the modified timestamp on the output binary to the git timestamp (to ensure a reproducible build)
    mod_timestamp: '{{ .CommitTimestamp }}'
    ldflags: |
@@ -71,11 +51,10 @@ archives:
  - format: tar.gz
    builds:
      - syft # i.e. Linux only
-  - format: zip # This is a hack for syft-macos! We don't actually intend to use _this_ ZIP file, we just need goreleaser to consider the ZIP file produced by gon (which will have the same file name) to be an artifact so we can use it downstream in publishing (e.g. to a homebrew tap)
+  - format: zip # This is a hack! We don't actually intend to use _this_ ZIP file, we just need goreleaser to consider the ZIP file produced by gon (which will have the same file name) to be an artifact so we can use it downstream in publishing (e.g. to a homebrew tap)
    id: syft-zip
    builds:
      - syft-macos
-      - syft-win

 signs:
  - artifacts: checksum
@@ -113,48 +92,15 @@ brews:
    description: *description

 dockers:
-  - image_templates:
+  - dockerfile: Dockerfile
+    image_templates:
      - "anchore/syft:latest"
-      - "anchore/syft:{{ .Tag }}-amd64"
-      - "anchore/syft:v{{ .Major }}-amd64"
-      - "anchore/syft:v{{ .Major }}.{{ .Minor }}-amd64"
-    dockerfile: Dockerfile
-    use: buildx
+      - "anchore/syft:{{ .Tag }}"
+      - "anchore/syft:v{{ .Major }}"
+      - "anchore/syft:v{{ .Major }}.{{ .Minor }}"
    build_flag_templates:
-      - "--platform=linux/amd64"
      - "--build-arg=BUILD_DATE={{.Date}}"
      - "--build-arg=BUILD_VERSION={{.Version}}"
      - "--build-arg=VCS_REF={{.FullCommit}}"
      - "--build-arg=VCS_URL={{.GitURL}}"
-
-  - image_templates:
-      - "anchore/syft:{{ .Tag }}-arm64v8"
-      - "anchore/syft:v{{ .Major }}-arm64v8"
-      - "anchore/syft:v{{ .Major }}.{{ .Minor }}-arm64v8"
-    goarch: arm64
-    dockerfile: Dockerfile
-    use: buildx
-    build_flag_templates:
-      - "--platform=linux/arm64/v8"
-      - "--build-arg=BUILD_DATE={{.Date}}"
-      - "--build-arg=BUILD_VERSION={{.Version}}"
-      - "--build-arg=VCS_REF={{.FullCommit}}"
-      - "--build-arg=VCS_URL={{.GitURL}}"
-
-docker_manifests:
-  - name_template: anchore/syft:{{ .Tag }}
-    image_templates:
-      - anchore/syft:{{ .Tag }}-amd64
-      - anchore/syft:v{{ .Major }}-amd64
-      - anchore/syft:v{{ .Major }}.{{ .Minor }}-amd64
-      - anchore/syft:{{ .Tag }}-arm64v8
-      - anchore/syft:v{{ .Major }}-arm64v8
-      - anchore/syft:v{{ .Major }}.{{ .Minor }}-arm64v8
-  - name_template: anchore/syft:latest
-    image_templates:
-      - anchore/syft:{{ .Tag }}-amd64
-      - anchore/syft:v{{ .Major }}-amd64
-      - anchore/syft:v{{ .Major }}.{{ .Minor }}-amd64
-      - anchore/syft:{{ .Tag }}-arm64v8
-      - anchore/syft:v{{ .Major }}-arm64v8
-      - anchore/syft:v{{ .Major }}.{{ .Minor }}-arm64v8
+    use_buildx: true
@@ -15,10 +15,10 @@ RESET := $(shell tput -T linux sgr0)
 TITLE := $(BOLD)$(PURPLE)
 SUCCESS := $(BOLD)$(GREEN)
 # the quality gate lower threshold for unit test total % coverage (by function statements)
-COVERAGE_THRESHOLD := 62
+COVERAGE_THRESHOLD := 65
 # CI cache busting values; change these if you want CI to not use previous stored cache
 INTEGRATION_CACHE_BUSTER="88738d2f"
-CLI_CACHE_BUSTER="9a2c03cf"
+CLI_CACHE_BUSTER="789bacdf"
 BOOTSTRAP_CACHE="c7afb99ad"

 ## Build variables
@@ -37,6 +37,10 @@ ifeq "$(strip $(VERSION))" ""
 override VERSION = $(shell git describe --always --tags --dirty)
 endif

+# used to generate the changelog from the second to last tag to the current tag (used in the release pipeline when the release tag is in place)
+LAST_TAG := $(shell git describe --abbrev=0 --tags $(shell git rev-list --tags --max-count=1))
+SECOND_TO_LAST_TAG := $(shell git describe --abbrev=0 --tags $(shell git rev-list --tags --skip=1 --max-count=1))
+
 ## Variable assertions

 ifndef TEMPDIR
@@ -99,8 +103,7 @@ bootstrap-tools: $(TEMPDIR)
 	GO111MODULE=off GOBIN=$(shell realpath $(TEMPDIR)) go get -u golang.org/x/perf/cmd/benchstat
 	curl -sSfL https://raw.githubusercontent.com/golangci/golangci-lint/master/install.sh | sh -s -- -b $(TEMPDIR)/ v1.42.1
 	curl -sSfL https://raw.githubusercontent.com/wagoodman/go-bouncer/master/bouncer.sh | sh -s -- -b $(TEMPDIR)/ v0.2.0
-	curl -sSfL https://raw.githubusercontent.com/anchore/chronicle/main/install.sh | sh -s -- -b $(TEMPDIR)/ v0.3.0
-	.github/scripts/goreleaser-install.sh -b $(TEMPDIR)/ v0.177.0
+	curl -sfL https://install.goreleaser.com/github.com/goreleaser/goreleaser.sh | sh -s -- -b $(TEMPDIR)/ v0.177.0

 .PHONY: bootstrap-go
 bootstrap-go:
@@ -135,7 +138,7 @@ lint-fix: ## Auto-format all source code + run golangci lint fixers
 	go mod tidy

 .PHONY: check-licenses
-check-licenses: ## Ensure transitive dependencies are compliant with the current license policy
+check-licenses:
 	$(TEMPDIR)/bouncer check

 check-go-mod-tidy:
@@ -190,11 +193,6 @@ fixtures:
 generate-json-schema:  ## Generate a new json schema
 	cd schema/json && go run generate.go

-.PHONY: generate-license-list
-generate-license-list: ## Generate an updated spdx license list
-	go generate ./internal/spdxlicense/...
-	gofmt -s -w ./internal/spdxlicense
-
 .PHONY: build
 build: $(SNAPSHOTDIR) ## Build release snapshot binaries and packages

@@ -205,9 +203,7 @@ $(SNAPSHOTDIR): ## Build snapshot release binaries and packages
 	cat .goreleaser.yaml >> $(TEMPDIR)/goreleaser.yaml

 	# build release snapshots
-	# DOCKER_CLI_EXPERIMENTAL needed to support multi architecture builds for goreleaser
 	BUILD_GIT_TREE_STATE=$(GITTREESTATE) \
-	DOCKER_CLI_EXPERIMENTAL=enabled \
 	$(TEMPDIR)/goreleaser release --skip-publish --skip-sign --rm-dist --snapshot --config $(TEMPDIR)/goreleaser.yaml

 # note: we cannot clean the snapshot directory since the pipeline builds the snapshot separately
@@ -253,19 +249,44 @@ cli: $(SNAPSHOTDIR) ## Run CLI tests
 	SYFT_BINARY_LOCATION='$(SNAPSHOT_CMD)' \
 		go test -count=1 -v ./test/cli

-.PHONY: changelog
-changelog: clean-changelog CHANGELOG.md
+.PHONY: changlog-release
+changelog-release:
+	@echo "Last tag: $(SECOND_TO_LAST_TAG)"
+	@docker run --rm \
+		-v "$(shell pwd)":/usr/local/src/your-app \
+		ferrarimarco/github-changelog-generator \
+		--user anchore \
+		--project $(BIN) \
+		-t ${GITHUB_TOKEN} \
+		--exclude-labels 'duplicate,question,invalid,wontfix,size:small,size:medium,size:large,size:x-large' \
+		--no-pr-wo-labels \
+		--no-issues-wo-labels \
+		--since-tag $(SECOND_TO_LAST_TAG)
+
+	@printf '\n$(BOLD)$(CYAN)Release $(VERSION) Changelog$(RESET)\n\n'
+	@cat CHANGELOG.md
+
+.PHONY: changelog-unreleased
+changelog-unreleased: ## show the current changelog that will be produced on the next release (note: requires GITHUB_TOKEN set)
+	@docker run -it --rm \
+		-v "$(shell pwd)":/usr/local/src/your-app \
+		ferrarimarco/github-changelog-generator \
+		--user anchore \
+		--project $(BIN) \
+		-t ${GITHUB_TOKEN} \
+		--exclude-labels 'duplicate,question,invalid,wontfix,size:small,size:medium,size:large,size:x-large' \
+		--since-tag $(LAST_TAG)
+
+	@printf '\n$(BOLD)$(CYAN)Unreleased Changes (closed PRs and issues will not be in the final changelog)$(RESET)\n'
+
 	@docker run -it --rm \
 		-v $(shell pwd)/CHANGELOG.md:/CHANGELOG.md \
 		rawkode/mdv \
 			-t 748.5989 \
 			/CHANGELOG.md

-CHANGELOG.md:
-	$(TEMPDIR)/chronicle -vv > CHANGELOG.md
-
 .PHONY: release
-release: clean-dist CHANGELOG.md  ## Build and publish final binaries and packages. Intended to be run only on macOS.
+release: clean-dist changelog-release ## Build and publish final binaries and packages. Intended to be run only on macOS.
 	$(call title,Publishing release artifacts)

 	# Prepare for macOS-specific signing process
@@ -280,11 +301,9 @@ release: clean-dist CHANGELOG.md  ## Build and publish final binaries and packag
 	cat .goreleaser.yaml >> $(TEMPDIR)/goreleaser.yaml

 	# release (note the version transformation from v0.7.0 --> 0.7.0)
-	# DOCKER_CLI_EXPERIMENTAL needed to support multi architecture builds for goreleaser
 	bash -c "\
 		BUILD_GIT_TREE_STATE=$(GITTREESTATE) \
 		VERSION=$(VERSION:v%=%) \
-		DOCKER_CLI_EXPERIMENTAL=enabled \
 		$(TEMPDIR)/goreleaser \
 			--rm-dist \
 			--config $(TEMPDIR)/goreleaser.yaml \
@@ -306,13 +325,9 @@ clean-snapshot:
 	rm -rf $(SNAPSHOTDIR) $(TEMPDIR)/goreleaser.yaml

 .PHONY: clean-dist
-clean-dist: clean-changelog
+clean-dist:
 	rm -rf $(DISTDIR) $(TEMPDIR)/goreleaser.yaml

-.PHONY: clean-changelog
-clean-changelog:
-	rm -f CHANGELOG.md
-
 clean-test-image-cache: clean-test-image-tar-cache clean-test-image-docker-cache

 .PHONY: clear-test-image-tar-cache
@@ -1,6 +1,4 @@
-<p align="center">
-    <img src="https://user-images.githubusercontent.com/5199289/136844524-1527b09f-c5cb-4aa9-be54-5aa92a6086c1.png" width="271" alt="Cute pink owl syft logo">
-</p>
+# syft

 [![Validations](https://github.com/anchore/syft/actions/workflows/validations.yaml/badge.svg)](https://github.com/anchore/syft/actions/workflows/validations.yaml)
 [![Go Report Card](https://goreportcard.com/badge/github.com/anchore/syft)](https://goreportcard.com/report/github.com/anchore/syft)
@@ -9,21 +7,19 @@
 [![License: Apache-2.0](https://img.shields.io/badge/License-Apache%202.0-blue.svg)](https://github.com/anchore/syft/blob/main/LICENSE)
 [![Slack Invite](https://img.shields.io/badge/Slack-Join-blue?logo=slack)](https://anchore.com/slack)

-A CLI tool and Go library for generating a Software Bill of Materials (SBOM) from container images and filesystems. Exceptional for vulnerability detection when used with a scanner tool like [Grype](https://github.com/anchore/grype).
+A CLI tool and go library for generating a Software Bill of Materials (SBOM) from container images and filesystems. Exceptional for vulnerability detection when used with a scanner tool like [Grype](https://github.com/anchore/grype).

-### Join us at the virtual OSS meetup!
+## We'll be at KubeCon 2021!

-When: December 1, 2021 @ 11am-noon PT (2-3pm ET)
+Attending KubeCon 2021 in person? Join us for a meetup on **Tuesday, October 12th**.

-We’ve got security experts from VMware and Anchore who will share their tips, tricks, and lessons learned on securing containers using [Syft](https://github.com/anchore/syft), [Grype](https://github.com/anchore/grype), and [Cartographer](https://github.com/vmware-tanzu/cartographer).
-
-Register now: https://get.anchore.com/anchore-oss-meetup-dec-1-2021/
+We’ll have free swag, giveaways, snacks, and sips. Space will be limited, so make sure to [save your seat](https://get.anchore.com/2021-kubecon-na-opensource-happy-hour/)!

 ---

 ![syft-demo](https://user-images.githubusercontent.com/590471/90277200-2a253000-de33-11ea-893f-32c219eea11a.gif)

-## Features
+**Features**
 - Catalog container images and filesystems to discover packages and libraries.
 - Supports packages and libraries from various ecosystems (APK, DEB, RPM, Ruby Bundles, Python Wheel/Egg/requirements.txt, JavaScript NPM/Yarn, Java JAR/EAR/WAR, Jenkins plugins JPI/HPI, Go modules)
 - Linux distribution identification (supports Alpine, BusyBox, CentOS/RedHat, Debian/Ubuntu flavored distributions)
@@ -93,7 +89,6 @@ docker-archive:path/to/yourimage.tar   use a tarball from disk for archives crea
 oci-archive:path/to/yourimage.tar      use a tarball from disk for OCI archives (from Skopeo or otherwise)
 oci-dir:path/to/yourimage              read directly from a path on disk for OCI layout directories (from Skopeo or otherwise)
 dir:path/to/yourproject                read directly from a path on disk (any directory)
-file:path/to/yourproject/file          read directly from a path on disk (any single file)
 registry:yourrepo/yourimage:tag        pull image directly from a registry (no container runtime required)
 ```

@@ -105,7 +100,7 @@ The output format for Syft is configurable as well:
 syft packages <image> -o <format>
 ```

-Where the `formats` available are:
+Where the `format`s available are:
 - `json`: Use this to get as much information out of Syft as possible!
 - `text`: A row-oriented, human-and-machine-friendly output.
 - `cyclonedx`: A XML report conforming to the [CycloneDX 1.2 specification](https://cyclonedx.org/specification/overview/).
@@ -113,96 +108,12 @@ Where the `formats` available are:
 - `spdx-json`: A JSON report conforming to the [SPDX 2.2 JSON Schema](https://github.com/spdx/spdx-spec/blob/v2.2/schemas/spdx-schema.json).
 - `table`: A columnar summary (default).

-## Private Registry Authentication
-
-### Local Docker Credentials
-When a container runtime is not present, Syft can still utilize credentials configured in common credential sources (such as `~/.docker/config.json`). 
-It will pull images from private registries using these credentials. The config file is where your credentials are stored when authenticating with private registries via some command like `docker login`. 
-For more information see the `go-containerregistry` [documentation](https://github.com/google/go-containerregistry/tree/main/pkg/authn).
-
-
-An example `config.json` looks something like this:
-```
-// config.json
-{
-	"auths": {
-		"registry.example.com": {
-			"username": "AzureDiamond",
-			"password": "hunter2"
-		}
-	}
-}
-```
-
-You can run the following command as an example. It details the mount/environment configuration a container needs to access a private registry:
-
-`docker run -v ./config.json:/config/config.json -e "DOCKER_CONFIG=/config" anchore/syft:latest  <private_image>`
-
-
-### Docker Credentials in Kubernetes
-The below section shows a simple workflow on how to mount this config file as a secret into a container on kubernetes.
-1. Create a secret. The value of `config.json` is important. It refers to the specification detailed [here](https://github.com/google/go-containerregistry/tree/main/pkg/authn#the-config-file). 
-Below this section is the `secret.yaml` file that the pod configuration will consume as a volume. 
-The key `config.json` is important. It will end up being the name of the file when mounted into the pod.
-    ```
-    # secret.yaml
-    
-    apiVersion: v1
-    kind: Secret
-    metadata:
-      name: registry-config
-      namespace: syft
-    data:
-      config.json: <base64 encoded config.json>
-    ```
-
-    `kubectl apply -f secret.yaml`
-
-
-2. Create your pod running syft. The env `DOCKER_CONFIG` is important because it advertises where to look for the credential file. 
-In the below example, setting `DOCKER_CONFIG=/config` informs syft that credentials can be found at `/config/config.json`. 
-This is why we used `config.json` as the key for our secret. When mounted into containers the secrets' key is used as the filename. 
-The `volumeMounts` section mounts our secret to `/config`. The `volumes` section names our volume and leverages the secret we created in step one.
-    ```
-    # pod.yaml
-    
-    apiVersion: v1
-    kind: Pod
-    spec:
-      containers:
-        - image: anchore/syft:latest
-          name: syft-private-registry-demo
-          env:
-            - name: DOCKER_CONFIG
-              value: /config
-          volumeMounts:
-          - mountPath: /config
-            name: registry-config
-            readOnly: true
-          args:
-            - <private_image>
-      volumes:
-      - name: registry-config
-        secret:
-          secretName: registry-config
-    ```
-
-    `kubectl apply -f pod.yaml`
-
-
-3. The user can now run `kubectl logs syft-private-registry-demo`. The logs should show the syft analysis for the `<private_image>` provided in the pod configuration.
-
-Using the above information, users should be able to configure private registry access without having to do so in the `grype` or `syft` configuration files.
-They will also not be dependent on a docker daemon, (or some other runtime software) for registry configuration and access.
-
 ## Configuration

 Configuration search paths:

 - `.syft.yaml`
 - `.syft/config.yaml`
- `<git repo root>/.syft.yaml`
- `<git repo root>/.syft/config.yaml`
 - `~/.syft.yaml`
 - `<XDG_CONFIG_HOME>/syft/config.yaml`

@@ -4,14 +4,13 @@ import (
 	"fmt"
 	"os"

-	"github.com/spf13/cobra"
-
 	"github.com/anchore/stereoscope"
 	"github.com/anchore/syft/internal/config"
 	"github.com/anchore/syft/internal/log"
 	"github.com/anchore/syft/internal/logger"
 	"github.com/anchore/syft/syft"
 	"github.com/gookit/color"
+	"github.com/spf13/cobra"
 	"github.com/spf13/viper"
 	"github.com/wagoodman/go-partybus"
 )
@@ -48,13 +47,7 @@ func initCmdAliasBindings() {
 		panic(err)
 	}

-	// enable all cataloger by default if power-user command is run
-	if activeCmd == powerUserCmd {
-		config.PowerUserCatalogerEnabledDefault()
-	}
-
-	switch activeCmd {
-	case packagesCmd, rootCmd:
+	if activeCmd == packagesCmd || activeCmd == rootCmd {
 		// note: we need to lazily bind config options since they are shared between both the root command
 		// and the packages command. Otherwise there will be global viper state that is in contention.
 		// See for more details: https://github.com/spf13/viper/issues/233 . Additionally, the bindings must occur BEFORE
@@ -64,7 +57,7 @@ func initCmdAliasBindings() {
 		if err = bindPackagesConfigOptions(activeCmd.Flags()); err != nil {
 			panic(err)
 		}
-	default:
+	} else {
 		// even though the root command or packages command is NOT being run, we still need default bindings
 		// such that application config parsing passes.
 		if err = bindPackagesConfigOptions(packagesCmd.Flags()); err != nil {
@@ -73,6 +66,7 @@ func initCmdAliasBindings() {
 	}
 }

+// nolint:forbidigo
 func initAppConfig() {
 	cfg, err := config.LoadApplicationConfig(viper.GetViper(), persistentOpts)
 	if err != nil {
@@ -8,14 +8,14 @@ import (
 	"github.com/docker/docker/api/types"
 	"github.com/docker/docker/api/types/filters"
 	"github.com/docker/docker/client"
-
 	"github.com/spf13/cobra"
 )

 // completionCmd represents the completion command
 var completionCmd = &cobra.Command{
-	Use:   "completion [bash|zsh|fish]",
-	Short: "Generate a shell completion for Syft (listing local docker images)",
+	Hidden: true,
+	Use:    "completion [bash|zsh|fish]",
+	Short:  "Generate a shell completion for Syft (listing local docker images)",
 	Long: `To load completions (docker image list):

 Bash:
@@ -86,7 +86,7 @@ func dockerImageValidArgsFunction(cmd *cobra.Command, args []string, toComplete
 }

 func listLocalDockerImages(prefix string) ([]string, error) {
-	var repoTags = make([]string, 0)
+	repoTags := make([]string, 0)
 	ctx := context.Background()
 	cli, err := client.NewClientWithOpts(client.FromEnv, client.WithAPIVersionNegotiation())
 	if err != nil {
@@ -14,7 +14,7 @@ import (
 // eventLoop listens to worker errors (from execution path), worker events (from a partybus subscription), and
 // signal interrupts. Is responsible for handling each event relative to a given UI an to coordinate eventing until
 // an eventual graceful exit.
-// nolint:funlen
+// nolint:gocognit,funlen
 func eventLoop(workerErrs <-chan error, signals <-chan os.Signal, subscription *partybus.Subscription, cleanupFn func(), uxs ...ui.UI) error {
 	defer cleanupFn()
 	events := subscription.Events()
@@ -41,10 +41,9 @@ func eventLoop(workerErrs <-chan error, signals <-chan os.Signal, subscription *
 			if err != nil {
 				// capture the error from the worker and unsubscribe to complete a graceful shutdown
 				retErr = multierror.Append(retErr, err)
-				_ = subscription.Unsubscribe()
-				// the worker has exited, we may have been mid-handling events for the UI which should now be
-				// ignored, in which case forcing a teardown of the UI irregardless of the state is required.
-				forceTeardown = true
+				if err := subscription.Unsubscribe(); err != nil {
+					retErr = multierror.Append(retErr, err)
+				}
 			}
 		case e, isOpen := <-events:
 			if !isOpen {
@@ -54,6 +53,7 @@ func eventLoop(workerErrs <-chan error, signals <-chan os.Signal, subscription *

 			if err := ux.Handle(e); err != nil {
 				if errors.Is(err, partybus.ErrUnsubscribe) {
+					log.Warnf("unable to unsubscribe from the event bus")
 					events = nil
 				} else {
 					retErr = multierror.Append(retErr, err)
@@ -10,14 +10,13 @@ import (
 	"github.com/anchore/syft/internal"
 	"github.com/anchore/syft/internal/anchore"
 	"github.com/anchore/syft/internal/bus"
-	"github.com/anchore/syft/internal/formats"
 	"github.com/anchore/syft/internal/log"
 	"github.com/anchore/syft/internal/ui"
-	"github.com/anchore/syft/internal/version"
-	"github.com/anchore/syft/syft/artifact"
+	"github.com/anchore/syft/syft"
+	"github.com/anchore/syft/syft/distro"
 	"github.com/anchore/syft/syft/event"
-	"github.com/anchore/syft/syft/format"
-	"github.com/anchore/syft/syft/sbom"
+	"github.com/anchore/syft/syft/pkg"
+	"github.com/anchore/syft/syft/presenter/packages"
 	"github.com/anchore/syft/syft/source"
 	"github.com/pkg/profile"
 	"github.com/spf13/cobra"
@@ -44,13 +43,13 @@ const (
    {{.appName}} {{.command}} oci-archive:path/to/yourimage.tar      use a tarball from disk for OCI archives (from Skopeo or otherwise)
    {{.appName}} {{.command}} oci-dir:path/to/yourimage              read directly from a path on disk for OCI layout directories (from Skopeo or otherwise)
    {{.appName}} {{.command}} dir:path/to/yourproject                read directly from a path on disk (any directory)
-    {{.appName}} {{.command}} file:path/to/yourproject/file          read directly from a path on disk (any single file)
    {{.appName}} {{.command}} registry:yourrepo/yourimage:tag        pull image directly from a registry (no container runtime required)
 `
 )

 var (
-	packagesPresenterOpt format.Option
+	packagesPresenterOpt packages.PresenterOption
+	packagesArgs         = cobra.MaximumNArgs(1)
 	packagesCmd          = &cobra.Command{
 		Use:   "packages [SOURCE]",
 		Short: "Generate a package SBOM",
@@ -59,13 +58,21 @@ var (
 			"appName": internal.ApplicationName,
 			"command": "packages",
 		}),
-		Args:          validateInputArgs,
+		Args:          packagesArgs,
 		SilenceUsage:  true,
 		SilenceErrors: true,
 		PreRunE: func(cmd *cobra.Command, args []string) error {
+			if len(args) == 0 {
+				err := cmd.Help()
+				if err != nil {
+					return err
+				}
+				return fmt.Errorf("an image/directory argument is required")
+			}
+
 			// set the presenter
-			presenterOption := format.ParseOption(appConfig.Output)
-			if presenterOption == format.UnknownFormatOption {
+			presenterOption := packages.ParsePresenterOption(appConfig.Output)
+			if presenterOption == packages.UnknownPresenterOption {
 				return fmt.Errorf("bad --output value '%s'", appConfig.Output)
 			}
 			packagesPresenterOpt = presenterOption
@@ -102,8 +109,8 @@ func setPackageFlags(flags *pflag.FlagSet) {
 		fmt.Sprintf("selection of layers to catalog, options=%v", source.AllScopes))

 	flags.StringP(
-		"output", "o", string(format.TableOption),
-		fmt.Sprintf("report output formatter, options=%v", format.AllOptions),
+		"output", "o", string(packages.TablePresenterOption),
+		fmt.Sprintf("report output formatter, options=%v", packages.AllPresenters),
 	)

 	flags.StringP(
@@ -187,18 +194,6 @@ func bindPackagesConfigOptions(flags *pflag.FlagSet) error {
 	return nil
 }

-func validateInputArgs(cmd *cobra.Command, args []string) error {
-	if len(args) == 0 {
-		// in the case that no arguments are given we want to show the help text and return with a non-0 return code.
-		if err := cmd.Help(); err != nil {
-			return fmt.Errorf("unable to display help: %w", err)
-		}
-		return fmt.Errorf("an image/directory argument is required")
-	}
-
-	return cobra.MaximumNArgs(1)(cmd, args)
-}
-
 func packagesExec(_ *cobra.Command, args []string) error {
 	// could be an image or a directory, with or without a scheme
 	userInput := args[0]
@@ -219,38 +214,15 @@ func packagesExec(_ *cobra.Command, args []string) error {
 		setupSignals(),
 		eventSubscription,
 		stereoscope.Cleanup,
-		ui.Select(isVerbose(), appConfig.Quiet, reporter)...,
+		ui.Select(appConfig.CliOptions.Verbosity > 0, appConfig.Quiet, reporter)...,
 	)
 }

-func isVerbose() (result bool) {
-	isPipedInput, err := internal.IsPipedInput()
-	if err != nil {
-		// since we can't tell if there was piped input we assume that there could be to disable the ETUI
-		log.Warnf("unable to determine if there is piped input: %+v", err)
-		return true
-	}
-	// verbosity should consider if there is piped input (in which case we should not show the ETUI)
-	return appConfig.CliOptions.Verbosity > 0 || isPipedInput
-}
-
 func packagesExecWorker(userInput string) <-chan error {
 	errs := make(chan error)
 	go func() {
 		defer close(errs)

-		tasks, err := tasks()
-		if err != nil {
-			errs <- err
-			return
-		}
-
-		f := formats.ByOption(packagesPresenterOpt)
-		if f == nil {
-			errs <- fmt.Errorf("unknown format: %s", packagesPresenterOpt)
-			return
-		}
-
 		checkForApplicationUpdate()

 		src, cleanup, err := source.New(userInput, appConfig.Registry.ToOptions())
@@ -258,54 +230,35 @@ func packagesExecWorker(userInput string) <-chan error {
 			errs <- fmt.Errorf("failed to determine image source: %w", err)
 			return
 		}
-		if cleanup != nil {
-			defer cleanup()
-		}
+		defer cleanup()

-		s := sbom.SBOM{
-			Source: src.Metadata,
-			Descriptor: sbom.Descriptor{
-				Name:          internal.ApplicationName,
-				Version:       version.FromBuild().Version,
-				Configuration: appConfig,
-			},
+		catalog, d, err := syft.CatalogPackages(src, appConfig.Package.Cataloger.ScopeOpt)
+		if err != nil {
+			errs <- fmt.Errorf("failed to catalog input: %w", err)
+			return
 		}

-		var relationships []<-chan artifact.Relationship
-		for _, task := range tasks {
-			c := make(chan artifact.Relationship)
-			relationships = append(relationships, c)
-
-			go runTask(task, &s.Artifacts, src, c, errs)
-		}
-		s.Relationships = append(s.Relationships, mergeRelationships(relationships...)...)
-
 		if appConfig.Anchore.Host != "" {
-			if err := runPackageSbomUpload(src, s); err != nil {
+			if err := runPackageSbomUpload(src, src.Metadata, catalog, d, appConfig.Package.Cataloger.ScopeOpt); err != nil {
 				errs <- err
 				return
 			}
 		}

 		bus.Publish(partybus.Event{
-			Type:  event.PresenterReady,
-			Value: f.Presenter(s),
+			Type: event.PresenterReady,
+			Value: packages.Presenter(packagesPresenterOpt, packages.PresenterConfig{
+				SourceMetadata: src.Metadata,
+				Catalog:        catalog,
+				Distro:         d,
+				Scope:          appConfig.Package.Cataloger.ScopeOpt,
+			}),
 		})
 	}()
 	return errs
 }

-func mergeRelationships(cs ...<-chan artifact.Relationship) (relationships []artifact.Relationship) {
-	for _, c := range cs {
-		for n := range c {
-			relationships = append(relationships, n)
-		}
-	}
-
-	return relationships
-}
-
-func runPackageSbomUpload(src *source.Source, s sbom.SBOM) error {
+func runPackageSbomUpload(src *source.Source, s source.Metadata, catalog *pkg.Catalog, d *distro.Distro, scope source.Scope) error {
 	log.Infof("uploading results to %s", appConfig.Anchore.Host)

 	if src.Metadata.Scheme != source.ImageScheme {
@@ -340,15 +293,17 @@ func runPackageSbomUpload(src *source.Source, s sbom.SBOM) error {

 	importCfg := anchore.ImportConfig{
 		ImageMetadata:           src.Image.Metadata,
-		SBOM:                    s,
+		SourceMetadata:          s,
+		Catalog:                 catalog,
+		Distro:                  d,
 		Dockerfile:              dockerfileContents,
 		OverwriteExistingUpload: appConfig.Anchore.OverwriteExistingImage,
+		Scope:                   scope,
 		Timeout:                 appConfig.Anchore.ImportTimeout,
 	}

 	if err := c.Import(context.Background(), importCfg); err != nil {
-		return fmt.Errorf("failed to upload results to host=%s: %+v", appConfig.Anchore.Host, err)
+		return fmt.Errorf("failed to upload results to host=%s: %w", appConfig.Anchore.Host, err)
 	}
-
 	return nil
 }
@@ -2,20 +2,16 @@ package cmd

 import (
 	"fmt"
-	"os"
+	"sync"

 	"github.com/anchore/stereoscope"
 	"github.com/anchore/syft/internal"
 	"github.com/anchore/syft/internal/bus"
-	"github.com/anchore/syft/internal/formats/syftjson"
 	"github.com/anchore/syft/internal/log"
+	"github.com/anchore/syft/internal/presenter/poweruser"
 	"github.com/anchore/syft/internal/ui"
-	"github.com/anchore/syft/internal/version"
-	"github.com/anchore/syft/syft/artifact"
 	"github.com/anchore/syft/syft/event"
-	"github.com/anchore/syft/syft/sbom"
 	"github.com/anchore/syft/syft/source"
-	"github.com/gookit/color"
 	"github.com/pkg/profile"
 	"github.com/spf13/cobra"
 	"github.com/wagoodman/go-partybus"
@@ -23,8 +19,6 @@ import (

 const powerUserExample = `  {{.appName}} {{.command}} <image>

-  DEPRECATED - THIS COMMAND WILL BE REMOVED in v1.0.0
-
  Only image sources are supported (e.g. docker: , docker-archive: , oci: , etc.), the directory source (dir:) is not supported.

  All behavior is controlled via application configuration and environment variables (see https://github.com/anchore/syft#configuration)
@@ -41,11 +35,19 @@ var powerUserCmd = &cobra.Command{
 		"appName": internal.ApplicationName,
 		"command": "power-user",
 	}),
-	Args:          validateInputArgs,
+	Args:          cobra.MaximumNArgs(1),
 	Hidden:        true,
 	SilenceUsage:  true,
 	SilenceErrors: true,
 	PreRunE: func(cmd *cobra.Command, args []string) error {
+		if len(args) == 0 {
+			err := cmd.Help()
+			if err != nil {
+				return err
+			}
+			return fmt.Errorf("an image/directory argument is required")
+		}
+
 		if appConfig.Dev.ProfileCPU && appConfig.Dev.ProfileMem {
 			return fmt.Errorf("cannot profile CPU and memory simultaneously")
 		}
@@ -78,10 +80,6 @@ func powerUserExec(_ *cobra.Command, args []string) error {
 		if err := closer(); err != nil {
 			log.Warnf("unable to write to report destination: %+v", err)
 		}
-
-		// inform user at end of run that command will be removed
-		deprecated := color.Style{color.Red, color.OpBold}.Sprint("DEPRECATED: This command will be removed in v1.0.0")
-		fmt.Fprintln(os.Stderr, deprecated)
 	}()

 	if err != nil {
@@ -93,19 +91,16 @@ func powerUserExec(_ *cobra.Command, args []string) error {
 		setupSignals(),
 		eventSubscription,
 		stereoscope.Cleanup,
-		ui.Select(isVerbose(), appConfig.Quiet, reporter)...,
+		ui.Select(appConfig.CliOptions.Verbosity > 0, appConfig.Quiet, reporter)...,
 	)
 }
+
 func powerUserExecWorker(userInput string) <-chan error {
 	errs := make(chan error)
 	go func() {
 		defer close(errs)

-		appConfig.Secrets.Cataloger.Enabled = true
-		appConfig.FileMetadata.Cataloger.Enabled = true
-		appConfig.FileContents.Cataloger.Enabled = true
-		appConfig.FileClassification.Cataloger.Enabled = true
-		tasks, err := tasks()
+		tasks, err := powerUserTasks()
 		if err != nil {
 			errs <- err
 			return
@@ -118,34 +113,31 @@ func powerUserExecWorker(userInput string) <-chan error {
 			errs <- err
 			return
 		}
-		if cleanup != nil {
-			defer cleanup()
+		defer cleanup()
+
+		analysisResults := poweruser.JSONDocumentConfig{
+			SourceMetadata:    src.Metadata,
+			ApplicationConfig: *appConfig,
 		}

-		s := sbom.SBOM{
-			Source: src.Metadata,
-			Descriptor: sbom.Descriptor{
-				Name:          internal.ApplicationName,
-				Version:       version.FromBuild().Version,
-				Configuration: appConfig,
-			},
-		}
-
-		var relationships []<-chan artifact.Relationship
+		wg := &sync.WaitGroup{}
 		for _, task := range tasks {
-			c := make(chan artifact.Relationship)
-			relationships = append(relationships, c)
-
-			go runTask(task, &s.Artifacts, src, c, errs)
+			wg.Add(1)
+			go func(task powerUserTask) {
+				defer wg.Done()
+				if err = task(&analysisResults, src); err != nil {
+					errs <- err
+					return
+				}
+			}(task)
 		}

-		s.Relationships = append(s.Relationships, mergeRelationships(relationships...)...)
+		wg.Wait()

 		bus.Publish(partybus.Event{
 			Type:  event.PresenterReady,
-			Value: syftjson.Format().Presenter(s),
+			Value: poweruser.NewJSONPresenter(analysisResults),
 		})
 	}()
-
 	return errs
 }
@@ -4,25 +4,24 @@ import (
 	"crypto"
 	"fmt"

+	"github.com/anchore/syft/internal/presenter/poweruser"
 	"github.com/anchore/syft/syft"
-	"github.com/anchore/syft/syft/artifact"
 	"github.com/anchore/syft/syft/file"
-	"github.com/anchore/syft/syft/sbom"
 	"github.com/anchore/syft/syft/source"
 )

-type task func(*sbom.Artifacts, *source.Source) ([]artifact.Relationship, error)
+type powerUserTask func(*poweruser.JSONDocumentConfig, *source.Source) error

-func tasks() ([]task, error) {
-	var tasks []task
+func powerUserTasks() ([]powerUserTask, error) {
+	var tasks []powerUserTask

-	generators := []func() (task, error){
-		generateCatalogPackagesTask,
-		generateCatalogFileMetadataTask,
-		generateCatalogFileDigestsTask,
-		generateCatalogSecretsTask,
-		generateCatalogFileClassificationsTask,
-		generateCatalogContentsTask,
+	generators := []func() (powerUserTask, error){
+		catalogPackagesTask,
+		catalogFileMetadataTask,
+		catalogFileDigestsTask,
+		catalogSecretsTask,
+		catalogFileClassificationsTask,
+		catalogContentsTask,
 	}

 	for _, generator := range generators {
@@ -30,7 +29,6 @@ func tasks() ([]task, error) {
 		if err != nil {
 			return nil, err
 		}
-
 		if task != nil {
 			tasks = append(tasks, task)
 		}
@@ -39,51 +37,51 @@ func tasks() ([]task, error) {
 	return tasks, nil
 }

-func generateCatalogPackagesTask() (task, error) {
+func catalogPackagesTask() (powerUserTask, error) {
 	if !appConfig.Package.Cataloger.Enabled {
 		return nil, nil
 	}

-	task := func(results *sbom.Artifacts, src *source.Source) ([]artifact.Relationship, error) {
-		packageCatalog, relationships, theDistro, err := syft.CatalogPackages(src, appConfig.Package.Cataloger.ScopeOpt)
+	task := func(results *poweruser.JSONDocumentConfig, src *source.Source) error {
+		packageCatalog, theDistro, err := syft.CatalogPackages(src, appConfig.Package.Cataloger.ScopeOpt)
 		if err != nil {
-			return nil, err
+			return err
 		}

 		results.PackageCatalog = packageCatalog
 		results.Distro = theDistro

-		return relationships, nil
+		return nil
 	}

 	return task, nil
 }

-func generateCatalogFileMetadataTask() (task, error) {
+func catalogFileMetadataTask() (powerUserTask, error) {
 	if !appConfig.FileMetadata.Cataloger.Enabled {
 		return nil, nil
 	}

 	metadataCataloger := file.NewMetadataCataloger()

-	task := func(results *sbom.Artifacts, src *source.Source) ([]artifact.Relationship, error) {
+	task := func(results *poweruser.JSONDocumentConfig, src *source.Source) error {
 		resolver, err := src.FileResolver(appConfig.FileMetadata.Cataloger.ScopeOpt)
 		if err != nil {
-			return nil, err
+			return err
 		}

 		result, err := metadataCataloger.Catalog(resolver)
 		if err != nil {
-			return nil, err
+			return err
 		}
 		results.FileMetadata = result
-		return nil, nil
+		return nil
 	}

 	return task, nil
 }

-func generateCatalogFileDigestsTask() (task, error) {
+func catalogFileDigestsTask() (powerUserTask, error) {
 	if !appConfig.FileMetadata.Cataloger.Enabled {
 		return nil, nil
 	}
@@ -112,24 +110,24 @@ func generateCatalogFileDigestsTask() (task, error) {
 		return nil, err
 	}

-	task := func(results *sbom.Artifacts, src *source.Source) ([]artifact.Relationship, error) {
+	task := func(results *poweruser.JSONDocumentConfig, src *source.Source) error {
 		resolver, err := src.FileResolver(appConfig.FileMetadata.Cataloger.ScopeOpt)
 		if err != nil {
-			return nil, err
+			return err
 		}

 		result, err := digestsCataloger.Catalog(resolver)
 		if err != nil {
-			return nil, err
+			return err
 		}
 		results.FileDigests = result
-		return nil, nil
+		return nil
 	}

 	return task, nil
 }

-func generateCatalogSecretsTask() (task, error) {
+func catalogSecretsTask() (powerUserTask, error) {
 	if !appConfig.Secrets.Cataloger.Enabled {
 		return nil, nil
 	}
@@ -144,24 +142,24 @@ func generateCatalogSecretsTask() (task, error) {
 		return nil, err
 	}

-	task := func(results *sbom.Artifacts, src *source.Source) ([]artifact.Relationship, error) {
+	task := func(results *poweruser.JSONDocumentConfig, src *source.Source) error {
 		resolver, err := src.FileResolver(appConfig.Secrets.Cataloger.ScopeOpt)
 		if err != nil {
-			return nil, err
+			return err
 		}

 		result, err := secretsCataloger.Catalog(resolver)
 		if err != nil {
-			return nil, err
+			return err
 		}
 		results.Secrets = result
-		return nil, nil
+		return nil
 	}

 	return task, nil
 }

-func generateCatalogFileClassificationsTask() (task, error) {
+func catalogFileClassificationsTask() (powerUserTask, error) {
 	if !appConfig.FileClassification.Cataloger.Enabled {
 		return nil, nil
 	}
@@ -172,24 +170,24 @@ func generateCatalogFileClassificationsTask() (task, error) {
 		return nil, err
 	}

-	task := func(results *sbom.Artifacts, src *source.Source) ([]artifact.Relationship, error) {
+	task := func(results *poweruser.JSONDocumentConfig, src *source.Source) error {
 		resolver, err := src.FileResolver(appConfig.FileClassification.Cataloger.ScopeOpt)
 		if err != nil {
-			return nil, err
+			return err
 		}

 		result, err := classifierCataloger.Catalog(resolver)
 		if err != nil {
-			return nil, err
+			return err
 		}
 		results.FileClassifications = result
-		return nil, nil
+		return nil
 	}

 	return task, nil
 }

-func generateCatalogContentsTask() (task, error) {
+func catalogContentsTask() (powerUserTask, error) {
 	if !appConfig.FileContents.Cataloger.Enabled {
 		return nil, nil
 	}
@@ -199,33 +197,19 @@ func generateCatalogContentsTask() (task, error) {
 		return nil, err
 	}

-	task := func(results *sbom.Artifacts, src *source.Source) ([]artifact.Relationship, error) {
+	task := func(results *poweruser.JSONDocumentConfig, src *source.Source) error {
 		resolver, err := src.FileResolver(appConfig.FileContents.Cataloger.ScopeOpt)
 		if err != nil {
-			return nil, err
+			return err
 		}

 		result, err := contentsCataloger.Catalog(resolver)
 		if err != nil {
-			return nil, err
+			return err
 		}
 		results.FileContents = result
-		return nil, nil
+		return nil
 	}

 	return task, nil
 }
-
-func runTask(t task, a *sbom.Artifacts, src *source.Source, c chan<- artifact.Relationship, errs chan<- error) {
-	defer close(c)
-
-	relationships, err := t(a, src)
-	if err != nil {
-		errs <- err
-		return
-	}
-
-	for _, relationship := range relationships {
-		c <- relationship
-	}
-}
@@ -11,22 +11,18 @@ import (

 func reportWriter() (io.Writer, func() error, error) {
 	nop := func() error { return nil }
-	path := strings.TrimSpace(appConfig.File)

+	path := strings.TrimSpace(appConfig.File)
 	switch len(path) {
 	case 0:
 		return os.Stdout, nop, nil
-
 	default:
-		reportFile, err := os.OpenFile(path, os.O_RDWR|os.O_CREATE|os.O_TRUNC, 0644)
-
+		reportFile, err := os.OpenFile(path, os.O_RDWR|os.O_CREATE|os.O_TRUNC, 0o644)
 		if err != nil {
 			return nil, nop, fmt.Errorf("unable to create report file: %w", err)
 		}
-
 		return reportFile, func() error {
 			log.Infof("report written to file=%q", path)
-
 			return reportFile.Close()
 		}, nil
 	}
@@ -24,6 +24,7 @@ var rootCmd = &cobra.Command{
 	ValidArgsFunction: packagesCmd.ValidArgsFunction,
 }

+// nolint:forbidigo
 func init() {
 	// set universal flags
 	rootCmd.PersistentFlags().StringVarP(&persistentOpts.ConfigPath, "config", "c", "", "application config file")
@@ -33,7 +34,6 @@ func init() {
 		flag, "q", false,
 		"suppress all logging output",
 	)
-
 	if err := viper.BindPFlag(flag, rootCmd.PersistentFlags().Lookup(flag)); err != nil {
 		fmt.Printf("unable to bind flag '%s': %+v", flag, err)
 		os.Exit(1)
@@ -6,7 +6,6 @@ import (
 	"os"

 	"github.com/anchore/syft/internal"
-
 	"github.com/anchore/syft/internal/version"
 	"github.com/spf13/cobra"
 )
@@ -24,6 +23,7 @@ func init() {
 	rootCmd.AddCommand(versionCmd)
 }

+// nolint:forbidigo
 func printVersion(_ *cobra.Command, _ []string) {
 	versionInfo := version.FromBuild()

@@ -7,52 +7,43 @@ require (
 	github.com/adrg/xdg v0.2.1
 	github.com/alecthomas/jsonschema v0.0.0-20210301060011-54c507b6f074
 	github.com/anchore/client-go v0.0.0-20210222170800-9c70f9b80bcf
-	github.com/anchore/go-presenter v0.0.0-20211102174526-0dbf20f6c7fa
 	github.com/anchore/go-rpmdb v0.0.0-20210914181456-a9c52348da63
 	github.com/anchore/go-testutils v0.0.0-20200925183923-d5f45b0d3c04
 	github.com/anchore/go-version v1.2.2-0.20200701162849-18adb9c92b9b
 	github.com/anchore/packageurl-go v0.0.0-20210922164639-b3fa992ebd29
-	github.com/anchore/stereoscope v0.0.0-20211116152349-7e4e1b56a15d
-	// we are hinting brotli to latest due to warning when installing archiver v3:
-	// go: warning: github.com/andybalholm/brotli@v1.0.1: retracted by module author: occasional panics and data corruption
-	github.com/andybalholm/brotli v1.0.4 // indirect
+	github.com/anchore/stereoscope v0.0.0-20211005213828-538011008578
 	github.com/antihax/optional v1.0.0
 	github.com/bmatcuk/doublestar/v2 v2.0.4
-	github.com/docker/docker v20.10.10+incompatible
+	github.com/docker/docker v17.12.0-ce-rc1.0.20200309214505-aa6a9891b09c+incompatible
 	github.com/dustin/go-humanize v1.0.0
 	github.com/facebookincubator/nvdtools v0.1.4
 	github.com/go-test/deep v1.0.7
-	github.com/google/go-cmp v0.5.6
-	github.com/google/uuid v1.2.0
+	github.com/google/uuid v1.1.1
 	github.com/gookit/color v1.2.7
 	github.com/hashicorp/go-multierror v1.1.0
 	github.com/hashicorp/go-version v1.2.0
-	github.com/jinzhu/copier v0.3.2
-	github.com/mgutz/ansi v0.0.0-20200706080929-d51e80ef957d // indirect
-	github.com/mholt/archiver/v3 v3.5.1
 	github.com/mitchellh/go-homedir v1.1.0
-	github.com/mitchellh/hashstructure/v2 v2.0.2
-	github.com/mitchellh/mapstructure v1.4.1
+	github.com/mitchellh/mapstructure v1.3.1
 	github.com/olekukonko/tablewriter v0.0.4
-	github.com/pelletier/go-toml v1.9.3
+	github.com/pelletier/go-toml v1.8.0
 	github.com/pkg/profile v1.5.0
 	github.com/scylladb/go-set v1.0.2
 	github.com/sergi/go-diff v1.1.0
-	github.com/sirupsen/logrus v1.8.1
+	github.com/sirupsen/logrus v1.6.0
 	github.com/spdx/tools-golang v0.1.0
-	github.com/spf13/afero v1.6.0
-	github.com/spf13/cobra v1.2.1
+	github.com/spf13/afero v1.2.2
+	github.com/spf13/cobra v1.0.1-0.20200909172742-8a63648dd905
 	github.com/spf13/pflag v1.0.5
-	github.com/spf13/viper v1.8.1
+	github.com/spf13/viper v1.7.0
 	github.com/stretchr/testify v1.7.0
 	github.com/vifraa/gopom v0.1.0
 	github.com/wagoodman/go-partybus v0.0.0-20210627031916-db1f5573bbc5
 	github.com/wagoodman/go-progress v0.0.0-20200731105512-1020f39e6240
-	github.com/wagoodman/jotframe v0.0.0-20211129225309-56b0d0a4aebb
+	github.com/wagoodman/jotframe v0.0.0-20200730190914-3517092dd163
 	github.com/x-cray/logrus-prefixed-formatter v0.5.2
 	github.com/xeipuuv/gojsonschema v1.2.0
-	golang.org/x/mod v0.4.2
-	golang.org/x/net v0.0.0-20211111160137-58aab5ef257a
-	golang.org/x/term v0.0.0-20210615171337-6886f2dfbf5b
-	gopkg.in/yaml.v2 v2.4.0
+	golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9
+	golang.org/x/mod v0.3.0
+	golang.org/x/net v0.0.0-20210813160813-60bc85c4be6d
+	gopkg.in/yaml.v2 v2.3.0
 )
@@ -9,8 +9,10 @@ import (
 	"github.com/anchore/client-go/pkg/external"
 	"github.com/anchore/stereoscope/pkg/image"
 	"github.com/anchore/syft/internal/bus"
+	"github.com/anchore/syft/syft/distro"
 	"github.com/anchore/syft/syft/event"
-	"github.com/anchore/syft/syft/sbom"
+	"github.com/anchore/syft/syft/pkg"
+	"github.com/anchore/syft/syft/source"
 	"github.com/antihax/optional"
 	"github.com/wagoodman/go-partybus"
 	"github.com/wagoodman/go-progress"
@@ -18,9 +20,12 @@ import (

 type ImportConfig struct {
 	ImageMetadata           image.Metadata
-	SBOM                    sbom.SBOM
+	SourceMetadata          source.Metadata
+	Catalog                 *pkg.Catalog
+	Distro                  *distro.Distro
 	Dockerfile              []byte
 	OverwriteExistingUpload bool
+	Scope                   source.Scope
 	Timeout                 uint
 }

@@ -58,7 +63,7 @@ func (c *Client) Import(ctx context.Context, cfg ImportConfig) error {
 	stage.Current = "starting session"
 	startOperation, _, err := c.client.ImportsApi.CreateOperation(authedCtx)
 	if err != nil {
-		var detail = "no details given"
+		detail := "no details given"
 		var openAPIErr external.GenericOpenAPIError
 		if errors.As(err, &openAPIErr) {
 			detail = string(openAPIErr.Body())
@@ -68,19 +73,19 @@ func (c *Client) Import(ctx context.Context, cfg ImportConfig) error {
 	prog.N++
 	sessionID := startOperation.Uuid

-	packageDigest, err := importPackageSBOM(authedCtx, c.client.ImportsApi, sessionID, cfg.SBOM, stage)
+	packageDigest, err := importPackageSBOM(authedCtx, c.client.ImportsApi, sessionID, cfg.SourceMetadata, cfg.Catalog, cfg.Distro, cfg.Scope, stage)
 	if err != nil {
 		return fmt.Errorf("failed to import Package SBOM: %w", err)
 	}
 	prog.N++

-	manifestDigest, err := importManifest(authedCtx, c.client.ImportsApi, sessionID, cfg.SBOM.Source.ImageMetadata.RawManifest, stage)
+	manifestDigest, err := importManifest(authedCtx, c.client.ImportsApi, sessionID, cfg.ImageMetadata.RawManifest, stage)
 	if err != nil {
 		return fmt.Errorf("failed to import Manifest: %w", err)
 	}
 	prog.N++

-	configDigest, err := importConfig(authedCtx, c.client.ImportsApi, sessionID, cfg.SBOM.Source.ImageMetadata.RawConfig, stage)
+	configDigest, err := importConfig(authedCtx, c.client.ImportsApi, sessionID, cfg.ImageMetadata.RawConfig, stage)
 	if err != nil {
 		return fmt.Errorf("failed to import Config: %w", err)
 	}
@@ -100,7 +105,7 @@ func (c *Client) Import(ctx context.Context, cfg ImportConfig) error {

 	_, _, err = c.client.ImagesApi.AddImage(authedCtx, imageModel, &opts)
 	if err != nil {
-		var detail = "no details given"
+		detail := "no details given"
 		var openAPIErr external.GenericOpenAPIError
 		if errors.As(err, &openAPIErr) {
 			detail = string(openAPIErr.Body())
@@ -116,7 +121,7 @@ func (c *Client) Import(ctx context.Context, cfg ImportConfig) error {
 }

 func addImageModel(imageMetadata image.Metadata, packageDigest, manifestDigest, dockerfileDigest, configDigest, sessionID string) external.ImageAnalysisRequest {
-	var tags = make([]string, len(imageMetadata.Tags))
+	tags := make([]string, len(imageMetadata.Tags))
 	for i, t := range imageMetadata.Tags {
 		tags[i] = t.String()
 	}
@@ -8,10 +8,9 @@ import (
 	"fmt"
 	"net/http"

-	"github.com/wagoodman/go-progress"
-
 	"github.com/anchore/client-go/pkg/external"
 	"github.com/anchore/syft/internal/log"
+	"github.com/wagoodman/go-progress"
 )

 type configImportAPI interface {
@@ -6,11 +6,9 @@ import (
 	"fmt"
 	"net/http"

-	"github.com/wagoodman/go-progress"
-
-	"github.com/anchore/syft/internal/log"
-
 	"github.com/anchore/client-go/pkg/external"
+	"github.com/anchore/syft/internal/log"
+	"github.com/wagoodman/go-progress"
 )

 type dockerfileImportAPI interface {
@@ -8,10 +8,9 @@ import (
 	"fmt"
 	"net/http"

-	"github.com/wagoodman/go-progress"
-
 	"github.com/anchore/client-go/pkg/external"
 	"github.com/anchore/syft/internal/log"
+	"github.com/wagoodman/go-progress"
 )

 type manifestImportAPI interface {
@@ -8,24 +8,23 @@ import (
 	"fmt"
 	"net/http"

-	"github.com/anchore/syft/syft/sbom"
-
-	"github.com/anchore/syft/internal/formats/syftjson"
-
-	"github.com/wagoodman/go-progress"
-
 	"github.com/anchore/client-go/pkg/external"
 	"github.com/anchore/syft/internal/log"
+	"github.com/anchore/syft/internal/presenter/packages"
+	"github.com/anchore/syft/syft/distro"
+	"github.com/anchore/syft/syft/pkg"
+	"github.com/anchore/syft/syft/source"
+	"github.com/wagoodman/go-progress"
 )

 type packageSBOMImportAPI interface {
 	ImportImagePackages(context.Context, string, external.ImagePackageManifest) (external.ImageImportContentResponse, *http.Response, error)
 }

-func packageSbomModel(s sbom.SBOM) (*external.ImagePackageManifest, error) {
+func packageSbomModel(s source.Metadata, catalog *pkg.Catalog, d *distro.Distro, scope source.Scope) (*external.ImagePackageManifest, error) {
 	var buf bytes.Buffer
-
-	err := syftjson.Format().Presenter(s).Present(&buf)
+	pres := packages.NewJSONPresenter(catalog, s, d, scope)
+	err := pres.Present(&buf)
 	if err != nil {
 		return nil, fmt.Errorf("unable to serialize results: %w", err)
 	}
@@ -39,11 +38,11 @@ func packageSbomModel(s sbom.SBOM) (*external.ImagePackageManifest, error) {
 	return &model, nil
 }

-func importPackageSBOM(ctx context.Context, api packageSBOMImportAPI, sessionID string, s sbom.SBOM, stage *progress.Stage) (string, error) {
+func importPackageSBOM(ctx context.Context, api packageSBOMImportAPI, sessionID string, s source.Metadata, catalog *pkg.Catalog, d *distro.Distro, scope source.Scope, stage *progress.Stage) (string, error) {
 	log.Debug("importing package SBOM")
 	stage.Current = "package SBOM"

-	model, err := packageSbomModel(s)
+	model, err := packageSbomModel(s, catalog, d, scope)
 	if err != nil {
 		return "", fmt.Errorf("unable to create PackageSBOM model: %w", err)
 	}
@@ -9,17 +9,18 @@ import (
 	"strings"
 	"testing"

-	"github.com/anchore/syft/syft/sbom"
+	"github.com/anchore/syft/internal/presenter/packages"
+
+	"github.com/wagoodman/go-progress"
+
+	"github.com/anchore/syft/syft/distro"
+
+	"github.com/docker/docker/pkg/ioutils"

 	"github.com/anchore/client-go/pkg/external"
-	"github.com/anchore/syft/internal/formats/syftjson"
-	syftjsonModel "github.com/anchore/syft/internal/formats/syftjson/model"
-	"github.com/anchore/syft/syft/distro"
 	"github.com/anchore/syft/syft/pkg"
 	"github.com/anchore/syft/syft/source"
-	"github.com/docker/docker/pkg/ioutils"
 	"github.com/go-test/deep"
-	"github.com/wagoodman/go-progress"
 )

 func must(c pkg.CPE, e error) pkg.CPE {
@@ -59,10 +60,8 @@ func TestPackageSbomToModel(t *testing.T) {
 		FoundBy: "foundBy",
 		Locations: []source.Location{
 			{
-				Coordinates: source.Coordinates{
-					RealPath:     "path",
-					FileSystemID: "layerID",
-				},
+				RealPath:     "path",
+				FileSystemID: "layerID",
 			},
 		},
 		Licenses: []string{"license"},
@@ -76,15 +75,7 @@ func TestPackageSbomToModel(t *testing.T) {

 	c := pkg.NewCatalog(p)

-	sbomResult := sbom.SBOM{
-		Artifacts: sbom.Artifacts{
-			PackageCatalog: c,
-			Distro:         &d,
-		},
-		Source: m,
-	}
-
-	model, err := packageSbomModel(sbomResult)
+	model, err := packageSbomModel(m, c, &d, source.AllLayersScope)
 	if err != nil {
 		t.Fatalf("unable to generate model from source material: %+v", err)
 	}
@@ -96,28 +87,20 @@ func TestPackageSbomToModel(t *testing.T) {
 		t.Fatalf("unable to marshal model: %+v", err)
 	}

-	s := sbom.SBOM{
-		Artifacts: sbom.Artifacts{
-			PackageCatalog: c,
-			Distro:         &d,
-		},
-		Source: m,
-	}
-
 	var buf bytes.Buffer
-	pres := syftjson.Format().Presenter(s)
+	pres := packages.NewJSONPresenter(c, m, &d, source.AllLayersScope)
 	if err := pres.Present(&buf); err != nil {
 		t.Fatalf("unable to get expected json: %+v", err)
 	}

 	// unmarshal expected result
-	var expectedDoc syftjsonModel.Document
+	var expectedDoc packages.JSONDocument
 	if err := json.Unmarshal(buf.Bytes(), &expectedDoc); err != nil {
 		t.Fatalf("unable to parse json doc: %+v", err)
 	}

 	// unmarshal actual result
-	var actualDoc syftjsonModel.Document
+	var actualDoc packages.JSONDocument
 	if err := json.Unmarshal(modelJSON, &actualDoc); err != nil {
 		t.Fatalf("unable to parse json doc: %+v", err)
 	}
@@ -159,10 +142,8 @@ func TestPackageSbomImport(t *testing.T) {
 		FoundBy: "foundBy",
 		Locations: []source.Location{
 			{
-				Coordinates: source.Coordinates{
-					RealPath:     "path",
-					FileSystemID: "layerID",
-				},
+				RealPath:     "path",
+				FileSystemID: "layerID",
 			},
 		},
 		Licenses: []string{"license"},
@@ -209,15 +190,7 @@ func TestPackageSbomImport(t *testing.T) {

 	d, _ := distro.NewDistro(distro.CentOS, "8.0", "")

-	sbomResult := sbom.SBOM{
-		Artifacts: sbom.Artifacts{
-			PackageCatalog: catalog,
-			Distro:         &d,
-		},
-		Source: m,
-	}
-
-	theModel, err := packageSbomModel(sbomResult)
+	theModel, err := packageSbomModel(m, catalog, &d, source.AllLayersScope)
 	if err != nil {
 		t.Fatalf("could not get sbom model: %+v", err)
 	}
@@ -256,7 +229,7 @@ func TestPackageSbomImport(t *testing.T) {
 	for _, test := range tests {
 		t.Run(test.name, func(t *testing.T) {

-			digest, err := importPackageSBOM(context.TODO(), test.api, sessionID, sbomResult, &progress.Stage{})
+			digest, err := importPackageSBOM(context.TODO(), test.api, sessionID, m, catalog, &d, source.AllLayersScope, &progress.Stage{})

 			// validate error handling
 			if err != nil && !test.expectsError {
@@ -15,8 +15,10 @@ package bus

 import "github.com/wagoodman/go-partybus"

-var publisher partybus.Publisher
-var active bool
+var (
+	publisher partybus.Publisher
+	active    bool
+)

 // SetPublisher sets the singleton event bus publisher. This is optional; if no bus is provided, the library will
 // behave no differently than if a bus had been provided.
@@ -3,10 +3,7 @@ package config
 import (
 	"errors"
 	"fmt"
-	"os"
-	"os/exec"
 	"path"
-	"path/filepath"
 	"reflect"
 	"strings"

@@ -20,8 +17,6 @@ import (

 var ErrApplicationConfigNotFound = fmt.Errorf("application config not found")

-var catalogerEnabledDefault = false
-
 type defaultValueLoader interface {
 	loadDefaultValues(*viper.Viper)
 }
@@ -49,11 +44,6 @@ type Application struct {
 	Registry           registry           `yaml:"registry" json:"registry" mapstructure:"registry"`
 }

-// PowerUserCatalogerEnabledDefault switches all catalogers to be enabled when running power-user command
-func PowerUserCatalogerEnabledDefault() {
-	catalogerEnabledDefault = true
-}
-
 func newApplicationConfig(v *viper.Viper, cliOpts CliOnlyOptions) *Application {
 	config := &Application{
 		CliOptions: cliOpts,
@@ -99,18 +89,42 @@ func (cfg Application) loadDefaultValues(v *viper.Viper) {
 	}
 }

+// build inflates simple config values into syft native objects (or other complex objects) after the config is fully read in.
 func (cfg *Application) parseConfigValues() error {
-	// parse application config options
-	for _, optionFn := range []func() error{
-		cfg.parseUploadOptions,
-		cfg.parseLogLevelOption,
-	} {
-		if err := optionFn(); err != nil {
-			return err
+	if cfg.Quiet {
+		// TODO: this is bad: quiet option trumps all other logging options
+		// we should be able to quiet the console logging and leave file logging alone...
+		// ... this will be an enhancement for later
+		cfg.Log.LevelOpt = logrus.PanicLevel
+	} else {
+		if cfg.Log.Level != "" {
+			if cfg.CliOptions.Verbosity > 0 {
+				return fmt.Errorf("cannot explicitly set log level (cfg file or env var) and use -v flag together")
+			}
+
+			lvl, err := logrus.ParseLevel(strings.ToLower(cfg.Log.Level))
+			if err != nil {
+				return fmt.Errorf("bad log level configured (%q): %w", cfg.Log.Level, err)
+			}
+			// set the log level explicitly
+			cfg.Log.LevelOpt = lvl
+		} else {
+			// set the log level implicitly
+			switch v := cfg.CliOptions.Verbosity; {
+			case v == 1:
+				cfg.Log.LevelOpt = logrus.InfoLevel
+			case v >= 2:
+				cfg.Log.LevelOpt = logrus.DebugLevel
+			default:
+				cfg.Log.LevelOpt = logrus.WarnLevel
+			}
 		}
 	}

-	// parse nested config options
+	if cfg.Anchore.Host == "" && cfg.Anchore.Dockerfile != "" {
+		return fmt.Errorf("cannot provide dockerfile option without enabling upload")
+	}
+
 	// for each field in the configuration struct, see if the field implements the parser interface
 	// note: the app config is a pointer, so we need to grab the elements explicitly (to traverse the address)
 	value := reflect.ValueOf(cfg).Elem()
@@ -123,52 +137,6 @@ func (cfg *Application) parseConfigValues() error {
 			}
 		}
 	}
-	return nil
-}
-
-func (cfg *Application) parseUploadOptions() error {
-	if cfg.Anchore.Host == "" && cfg.Anchore.Dockerfile != "" {
-		return fmt.Errorf("cannot provide dockerfile option without enabling upload")
-	}
-	return nil
-}
-
-func (cfg *Application) parseLogLevelOption() error {
-	switch {
-	case cfg.Quiet:
-		// TODO: this is bad: quiet option trumps all other logging options (such as to a file on disk)
-		// we should be able to quiet the console logging and leave file logging alone...
-		// ... this will be an enhancement for later
-		cfg.Log.LevelOpt = logrus.PanicLevel
-	case cfg.Log.Level != "":
-		if cfg.CliOptions.Verbosity > 0 {
-			return fmt.Errorf("cannot explicitly set log level (cfg file or env var) and use -v flag together")
-		}
-
-		lvl, err := logrus.ParseLevel(strings.ToLower(cfg.Log.Level))
-		if err != nil {
-			return fmt.Errorf("bad log level configured (%q): %w", cfg.Log.Level, err)
-		}
-
-		cfg.Log.LevelOpt = lvl
-		if cfg.Log.LevelOpt >= logrus.InfoLevel {
-			cfg.CliOptions.Verbosity = 1
-		}
-	default:
-
-		switch v := cfg.CliOptions.Verbosity; {
-		case v == 1:
-			cfg.Log.LevelOpt = logrus.InfoLevel
-		case v >= 2:
-			cfg.Log.LevelOpt = logrus.DebugLevel
-		default:
-			cfg.Log.LevelOpt = logrus.ErrorLevel
-		}
-	}
-
-	if cfg.Log.Level == "" {
-		cfg.Log.Level = cfg.Log.LevelOpt.String()
-	}

 	return nil
 }
@@ -176,7 +144,6 @@ func (cfg *Application) parseLogLevelOption() error {
 func (cfg Application) String() string {
 	// yaml is pretty human friendly (at least when compared to json)
 	appCfgStr, err := yaml.Marshal(&cfg)
-
 	if err != nil {
 		return err.Error()
 	}
@@ -209,80 +176,44 @@ func readConfig(v *viper.Viper, configPath string) error {
 	// 1. look for .<appname>.yaml (in the current directory)
 	v.AddConfigPath(".")
 	v.SetConfigName("." + internal.ApplicationName)
-	if exists, err := readViperConfig(v); exists || err != nil {
-		return err
+	if err = v.ReadInConfig(); err == nil {
+		return nil
+	} else if !errors.As(err, &viper.ConfigFileNotFoundError{}) {
+		return fmt.Errorf("unable to parse config=%q: %w", v.ConfigFileUsed(), err)
 	}

 	// 2. look for .<appname>/config.yaml (in the current directory)
 	v.AddConfigPath("." + internal.ApplicationName)
 	v.SetConfigName("config")
-	if exists, err := readViperConfig(v); exists || err != nil {
-		return err
+	if err = v.ReadInConfig(); err == nil {
+		return nil
+	} else if !errors.As(err, &viper.ConfigFileNotFoundError{}) {
+		return fmt.Errorf("unable to parse config=%q: %w", v.ConfigFileUsed(), err)
 	}

-	if root := gitRepoRoot(); root != "" {
-		// 3. look for <git repo root>/.<appname>.yaml, where the repo root is defined by "git rev-parse --show-toplevel"
-		v.AddConfigPath(root)
-		v.SetConfigName("." + internal.ApplicationName)
-		if exists, err := readViperConfig(v); exists {
-			if err != nil {
-				return err
-			}
-			return os.Chdir(root)
-		}
-
-		// 4. look for <git repo root>/.<appname>/config.yaml, where the repo root is defined by "git rev-parse --show-toplevel"
-		v.AddConfigPath(filepath.Join(root, "."+internal.ApplicationName))
-		v.SetConfigName("config")
-		if exists, err := readViperConfig(v); exists {
-			if err != nil {
-				return err
-			}
-			return os.Chdir(root)
-		}
-	}
-
-	// 5. look for ~/.<appname>.yaml
+	// 3. look for ~/.<appname>.yaml
 	home, err := homedir.Dir()
 	if err == nil {
 		v.AddConfigPath(home)
 		v.SetConfigName("." + internal.ApplicationName)
-		if exists, err := readViperConfig(v); exists || err != nil {
-			return err
+		if err = v.ReadInConfig(); err == nil {
+			return nil
+		} else if !errors.As(err, &viper.ConfigFileNotFoundError{}) {
+			return fmt.Errorf("unable to parse config=%q: %w", v.ConfigFileUsed(), err)
 		}
 	}

-	// 6. look for <appname>/config.yaml in xdg locations (starting with xdg home config dir, then moving upwards)
+	// 4. look for <appname>/config.yaml in xdg locations (starting with xdg home config dir, then moving upwards)
 	v.AddConfigPath(path.Join(xdg.ConfigHome, internal.ApplicationName))
 	for _, dir := range xdg.ConfigDirs {
 		v.AddConfigPath(path.Join(dir, internal.ApplicationName))
 	}
 	v.SetConfigName("config")
-	if exists, err := readViperConfig(v); exists || err != nil {
-		return err
+	if err = v.ReadInConfig(); err == nil {
+		return nil
+	} else if !errors.As(err, &viper.ConfigFileNotFoundError{}) {
+		return fmt.Errorf("unable to parse config=%q: %w", v.ConfigFileUsed(), err)
 	}

 	return ErrApplicationConfigNotFound
 }
-
-func readViperConfig(v *viper.Viper) (bool, error) {
-	err := v.ReadInConfig()
-	if err == nil {
-		return true, nil
-	} else if errors.As(err, &viper.ConfigFileNotFoundError{}) {
-		return false, nil
-	}
-	return true, fmt.Errorf("unable to parse config=%q: %w", v.ConfigFileUsed(), err)
-}
-
-func gitRepoRoot() string {
-	root, err := exec.Command("git", "rev-parse", "--show-toplevel").Output()
-	if err != nil {
-		return ""
-	}
-	absRepoRoot, err := filepath.Abs(strings.TrimSpace(string(root)))
-	if err != nil {
-		return ""
-	}
-	return absRepoRoot
-}
@@ -10,7 +10,7 @@ type fileClassification struct {
 }

 func (cfg fileClassification) loadDefaultValues(v *viper.Viper) {
-	v.SetDefault("file-classification.cataloger.enabled", catalogerEnabledDefault)
+	v.SetDefault("file-classification.cataloger.enabled", true)
 	v.SetDefault("file-classification.cataloger.scope", source.SquashedScope)
 }

@@ -13,7 +13,7 @@ type fileContents struct {
 }

 func (cfg fileContents) loadDefaultValues(v *viper.Viper) {
-	v.SetDefault("file-contents.cataloger.enabled", catalogerEnabledDefault)
+	v.SetDefault("file-contents.cataloger.enabled", true)
 	v.SetDefault("file-contents.cataloger.scope", source.SquashedScope)
 	v.SetDefault("file-contents.skip-files-above-size", 1*file.MB)
 	v.SetDefault("file-contents.globs", []string{})
@@ -11,7 +11,7 @@ type FileMetadata struct {
 }

 func (cfg FileMetadata) loadDefaultValues(v *viper.Viper) {
-	v.SetDefault("file-metadata.cataloger.enabled", catalogerEnabledDefault)
+	v.SetDefault("file-metadata.cataloger.enabled", true)
 	v.SetDefault("file-metadata.cataloger.scope", source.SquashedScope)
 	v.SetDefault("file-metadata.digests", []string{"sha256"})
 }
@@ -4,7 +4,6 @@ import (
 	"os"

 	"github.com/anchore/stereoscope/pkg/image"
-
 	"github.com/spf13/viper"
 )

@@ -58,7 +57,7 @@ func hasNonEmptyCredentials(username, password, token string) bool {
 }

 func (cfg *registry) ToOptions() *image.RegistryOptions {
-	var auth = make([]image.RegistryCredentials, len(cfg.Auth))
+	auth := make([]image.RegistryCredentials, len(cfg.Auth))
 	for i, a := range cfg.Auth {
 		auth[i] = image.RegistryCredentials{
 			Authority: a.Authority,
@@ -15,7 +15,7 @@ type secrets struct {
 }

 func (cfg secrets) loadDefaultValues(v *viper.Viper) {
-	v.SetDefault("secrets.cataloger.enabled", catalogerEnabledDefault)
+	v.SetDefault("secrets.cataloger.enabled", true)
 	v.SetDefault("secrets.cataloger.scope", source.AllLayersScope)
 	v.SetDefault("secrets.reveal-values", false)
 	v.SetDefault("secrets.skip-files-above-size", 1*file.MB)
@@ -6,5 +6,5 @@ const (

 	// JSONSchemaVersion is the current schema version output by the JSON presenter
 	// This is roughly following the "SchemaVer" guidelines for versioning the JSON schema. Please see schema/json/README.md for details on how to increment.
-	JSONSchemaVersion = "2.0.0"
+	JSONSchemaVersion = "1.1.0"
 )
@@ -1,6 +1,7 @@
 package internal

 import (
+	"errors"
 	"fmt"
 	"io"
 	"os"
@@ -15,24 +16,23 @@ func CloseAndLogError(closer io.Closer, location string) {
 	}
 }

-type ErrPath struct {
+type PathError struct {
 	Path string
 	Err  error
 }

-func (e ErrPath) Error() string {
+func (e PathError) Error() string {
 	return fmt.Sprintf("unable to observe contents of %+v: %v", e.Path, e.Err)
 }

-func IsErrPath(err error) bool {
-	_, ok := err.(ErrPath)
-	return ok
+func IsPathError(err error) bool {
+	return errors.As(err, &PathError{})
 }

 func IsErrPathPermission(err error) bool {
-	pathErr, ok := err.(ErrPath)
-	if ok {
+	var pathErr *PathError
+	if errors.As(err, pathErr) {
 		return os.IsPermission(pathErr.Err)
 	}
-	return ok
+	return false
 }
@@ -24,12 +24,12 @@ const (

 const perFileReadLimit = 2 * GB

-type errZipSlipDetected struct {
+type zipSlipDetectedError struct {
 	Prefix   string
 	JoinArgs []string
 }

-func (e *errZipSlipDetected) Error() string {
+func (e *zipSlipDetectedError) Error() string {
 	return fmt.Sprintf("paths are not allowed to resolve outside of the root prefix (%q). Destination: %q", e.Prefix, e.JoinArgs)
 }

@@ -197,7 +197,7 @@ func safeJoin(prefix string, dest ...string) (string, error) {
 	joinResult := filepath.Join(append([]string{prefix}, dest...)...)
 	cleanJoinResult := filepath.Clean(joinResult)
 	if !strings.HasPrefix(cleanJoinResult, filepath.Clean(prefix)) {
-		return "", &errZipSlipDetected{
+		return "", &zipSlipDetectedError{
 			Prefix:   prefix,
 			JoinArgs: dest,
 		}
@@ -299,7 +299,7 @@ func TestSafeJoin(t *testing.T) {
 				"../../../etc/passwd",
 			},
 			expected:     "",
-			errAssertion: assertErrorAs(&errZipSlipDetected{}),
+			errAssertion: assertErrorAs(&zipSlipDetectedError{}),
 		},
 		{
 			prefix: "/a/place",
@@ -308,7 +308,7 @@ func TestSafeJoin(t *testing.T) {
 				"../",
 			},
 			expected:     "",
-			errAssertion: assertErrorAs(&errZipSlipDetected{}),
+			errAssertion: assertErrorAs(&zipSlipDetectedError{}),
 		},
 		{
 			prefix: "/a/place",
@@ -316,7 +316,7 @@ func TestSafeJoin(t *testing.T) {
 				"../",
 			},
 			expected:     "",
-			errAssertion: assertErrorAs(&errZipSlipDetected{}),
+			errAssertion: assertErrorAs(&zipSlipDetectedError{}),
 		},
 	}

@@ -3,6 +3,7 @@ package file
 import (
 	"archive/zip"
 	"encoding/binary"
+	"errors"
 	"fmt"
 	"io"
 	"os"
@@ -91,7 +92,7 @@ func findArchiveStartOffset(r io.ReaderAt, size int64) (startOfArchive uint64, e
 			bLen = size
 		}
 		buf = make([]byte, int(bLen))
-		if _, err := r.ReadAt(buf, size-bLen); err != nil && err != io.EOF {
+		if _, err := r.ReadAt(buf, size-bLen); err != nil && !errors.Is(err, io.EOF) {
 			return 0, err
 		}
 		if p := findSignatureInBlock(buf); p >= 0 {
@@ -1,19 +0,0 @@
-package spdxhelpers
-
-import "github.com/anchore/syft/syft/pkg"
-
-func Description(p pkg.Package) string {
-	if hasMetadata(p) {
-		switch metadata := p.Metadata.(type) {
-		case pkg.ApkMetadata:
-			return metadata.Description
-		case pkg.NpmPackageJSONMetadata:
-			return metadata.Description
-		}
-	}
-	return ""
-}
-
-func hasMetadata(p pkg.Package) bool {
-	return p.Metadata != nil
-}
@@ -1,56 +0,0 @@
-package spdxhelpers
-
-import (
-	"testing"
-
-	"github.com/anchore/syft/syft/pkg"
-	"github.com/stretchr/testify/assert"
-)
-
-func Test_Description(t *testing.T) {
-	tests := []struct {
-		name     string
-		input    pkg.Package
-		expected string
-	}{
-		{
-			// note: since this is an optional field, no value is preferred over NONE or NOASSERTION
-			name:     "no metadata",
-			input:    pkg.Package{},
-			expected: "",
-		},
-		{
-			name: "from apk",
-			input: pkg.Package{
-				Metadata: pkg.ApkMetadata{
-					Description: "a description!",
-				},
-			},
-			expected: "a description!",
-		},
-		{
-			name: "from npm",
-			input: pkg.Package{
-				Metadata: pkg.NpmPackageJSONMetadata{
-					Description: "a description!",
-				},
-			},
-			expected: "a description!",
-		},
-		{
-			// note: since this is an optional field, no value is preferred over NONE or NOASSERTION
-			name: "empty",
-			input: pkg.Package{
-				Metadata: pkg.NpmPackageJSONMetadata{
-					Homepage: "",
-				},
-			},
-			expected: "",
-		},
-	}
-	for _, test := range tests {
-		t.Run(test.name, func(t *testing.T) {
-			assert.Equal(t, test.expected, Description(test.input))
-		})
-	}
-}
@@ -1,23 +0,0 @@
-package spdxhelpers
-
-import "github.com/anchore/syft/syft/pkg"
-
-func DownloadLocation(p pkg.Package) string {
-	// 3.7: Package Download Location
-	// Cardinality: mandatory, one
-	// NONE if there is no download location whatsoever.
-	// NOASSERTION if:
-	//   (i) the SPDX file creator has attempted to but cannot reach a reasonable objective determination;
-	//   (ii) the SPDX file creator has made no attempt to determine this field; or
-	//   (iii) the SPDX file creator has intentionally provided no information (no meaning should be implied by doing so).
-
-	if hasMetadata(p) {
-		switch metadata := p.Metadata.(type) {
-		case pkg.ApkMetadata:
-			return NoneIfEmpty(metadata.URL)
-		case pkg.NpmPackageJSONMetadata:
-			return NoneIfEmpty(metadata.URL)
-		}
-	}
-	return "NOASSERTION"
-}
@@ -1,54 +0,0 @@
-package spdxhelpers
-
-import (
-	"testing"
-
-	"github.com/anchore/syft/syft/pkg"
-	"github.com/stretchr/testify/assert"
-)
-
-func Test_DownloadLocation(t *testing.T) {
-	tests := []struct {
-		name     string
-		input    pkg.Package
-		expected string
-	}{
-		{
-			name:     "no metadata",
-			input:    pkg.Package{},
-			expected: "NOASSERTION",
-		},
-		{
-			name: "from apk",
-			input: pkg.Package{
-				Metadata: pkg.ApkMetadata{
-					URL: "http://a-place.gov",
-				},
-			},
-			expected: "http://a-place.gov",
-		},
-		{
-			name: "from npm",
-			input: pkg.Package{
-				Metadata: pkg.NpmPackageJSONMetadata{
-					URL: "http://a-place.gov",
-				},
-			},
-			expected: "http://a-place.gov",
-		},
-		{
-			name: "empty",
-			input: pkg.Package{
-				Metadata: pkg.NpmPackageJSONMetadata{
-					URL: "",
-				},
-			},
-			expected: "NONE",
-		},
-	}
-	for _, test := range tests {
-		t.Run(test.name, func(t *testing.T) {
-			assert.Equal(t, test.expected, DownloadLocation(test.input))
-		})
-	}
-}
@@ -1,51 +0,0 @@
-package spdxhelpers
-
-import (
-	"github.com/anchore/syft/internal/formats/spdx22json/model"
-	"github.com/anchore/syft/internal/log"
-	"github.com/anchore/syft/syft/pkg"
-)
-
-func ExternalRefs(p pkg.Package) (externalRefs []model.ExternalRef) {
-	externalRefs = make([]model.ExternalRef, 0)
-
-	for _, c := range p.CPEs {
-		externalRefs = append(externalRefs, model.ExternalRef{
-			ReferenceCategory: model.SecurityReferenceCategory,
-			ReferenceLocator:  c.BindToFmtString(),
-			ReferenceType:     model.Cpe23ExternalRefType,
-		})
-	}
-
-	if p.PURL != "" {
-		externalRefs = append(externalRefs, model.ExternalRef{
-			ReferenceCategory: model.PackageManagerReferenceCategory,
-			ReferenceLocator:  p.PURL,
-			ReferenceType:     model.PurlExternalRefType,
-		})
-	}
-	return externalRefs
-}
-
-func ExtractPURL(refs []model.ExternalRef) string {
-	for _, r := range refs {
-		if r.ReferenceType == model.PurlExternalRefType {
-			return r.ReferenceLocator
-		}
-	}
-	return ""
-}
-
-func ExtractCPEs(refs []model.ExternalRef) (cpes []pkg.CPE) {
-	for _, r := range refs {
-		if r.ReferenceType == model.Cpe23ExternalRefType {
-			cpe, err := pkg.NewCPE(r.ReferenceLocator)
-			if err != nil {
-				log.Warnf("unable to extract SPDX CPE=%q: %+v", r.ReferenceLocator, err)
-				continue
-			}
-			cpes = append(cpes, cpe)
-		}
-	}
-	return cpes
-}
@@ -1,45 +0,0 @@
-package spdxhelpers
-
-import (
-	"testing"
-
-	"github.com/anchore/syft/internal/formats/spdx22json/model"
-	"github.com/anchore/syft/syft/pkg"
-	"github.com/stretchr/testify/assert"
-)
-
-func Test_ExternalRefs(t *testing.T) {
-	testCPE := pkg.MustCPE("cpe:2.3:a:name:name:3.2:*:*:*:*:*:*:*")
-	tests := []struct {
-		name     string
-		input    pkg.Package
-		expected []model.ExternalRef
-	}{
-		{
-			name: "cpe + purl",
-			input: pkg.Package{
-				CPEs: []pkg.CPE{
-					testCPE,
-				},
-				PURL: "a-purl",
-			},
-			expected: []model.ExternalRef{
-				{
-					ReferenceCategory: model.SecurityReferenceCategory,
-					ReferenceLocator:  testCPE.BindToFmtString(),
-					ReferenceType:     model.Cpe23ExternalRefType,
-				},
-				{
-					ReferenceCategory: model.PackageManagerReferenceCategory,
-					ReferenceLocator:  "a-purl",
-					ReferenceType:     model.PurlExternalRefType,
-				},
-			},
-		},
-	}
-	for _, test := range tests {
-		t.Run(test.name, func(t *testing.T) {
-			assert.ElementsMatch(t, test.expected, ExternalRefs(test.input))
-		})
-	}
-}
@@ -1,15 +0,0 @@
-package spdxhelpers
-
-import "github.com/anchore/syft/syft/pkg"
-
-func Homepage(p pkg.Package) string {
-	if hasMetadata(p) {
-		switch metadata := p.Metadata.(type) {
-		case pkg.GemMetadata:
-			return metadata.Homepage
-		case pkg.NpmPackageJSONMetadata:
-			return metadata.Homepage
-		}
-	}
-	return ""
-}
@@ -1,56 +0,0 @@
-package spdxhelpers
-
-import (
-	"testing"
-
-	"github.com/anchore/syft/syft/pkg"
-	"github.com/stretchr/testify/assert"
-)
-
-func Test_Homepage(t *testing.T) {
-	tests := []struct {
-		name     string
-		input    pkg.Package
-		expected string
-	}{
-		{
-			// note: since this is an optional field, no value is preferred over NONE or NOASSERTION
-			name:     "no metadata",
-			input:    pkg.Package{},
-			expected: "",
-		},
-		{
-			name: "from gem",
-			input: pkg.Package{
-				Metadata: pkg.GemMetadata{
-					Homepage: "http://a-place.gov",
-				},
-			},
-			expected: "http://a-place.gov",
-		},
-		{
-			name: "from npm",
-			input: pkg.Package{
-				Metadata: pkg.NpmPackageJSONMetadata{
-					Homepage: "http://a-place.gov",
-				},
-			},
-			expected: "http://a-place.gov",
-		},
-		{
-			// note: since this is an optional field, no value is preferred over NONE or NOASSERTION
-			name: "empty",
-			input: pkg.Package{
-				Metadata: pkg.NpmPackageJSONMetadata{
-					Homepage: "",
-				},
-			},
-			expected: "",
-		},
-	}
-	for _, test := range tests {
-		t.Run(test.name, func(t *testing.T) {
-			assert.Equal(t, test.expected, Homepage(test.input))
-		})
-	}
-}
@@ -1,37 +0,0 @@
-package spdxhelpers
-
-import (
-	"strings"
-
-	"github.com/anchore/syft/internal/spdxlicense"
-	"github.com/anchore/syft/syft/pkg"
-)
-
-func License(p pkg.Package) string {
-	// source: https://spdx.github.io/spdx-spec/3-package-information/#313-concluded-license
-	// The options to populate this field are limited to:
-	// A valid SPDX License Expression as defined in Appendix IV;
-	// NONE, if the SPDX file creator concludes there is no license available for this package; or
-	// NOASSERTION if:
-	//   (i) the SPDX file creator has attempted to but cannot reach a reasonable objective determination;
-	//   (ii) the SPDX file creator has made no attempt to determine this field; or
-	//   (iii) the SPDX file creator has intentionally provided no information (no meaning should be implied by doing so).
-
-	if len(p.Licenses) == 0 {
-		return "NONE"
-	}
-
-	// take all licenses and assume an AND expression; for information about license expressions see https://spdx.github.io/spdx-spec/appendix-IV-SPDX-license-expressions/
-	var parsedLicenses []string
-	for _, l := range p.Licenses {
-		if value, exists := spdxlicense.ID(l); exists {
-			parsedLicenses = append(parsedLicenses, value)
-		}
-	}
-
-	if len(parsedLicenses) == 0 {
-		return "NOASSERTION"
-	}
-
-	return strings.Join(parsedLicenses, " AND ")
-}
@@ -1,73 +0,0 @@
-package spdxhelpers
-
-import (
-	"testing"
-
-	"github.com/anchore/syft/syft/pkg"
-	"github.com/stretchr/testify/assert"
-)
-
-func Test_License(t *testing.T) {
-	tests := []struct {
-		name     string
-		input    pkg.Package
-		expected string
-	}{
-		{
-			name:     "no licenses",
-			input:    pkg.Package{},
-			expected: "NONE",
-		},
-		{
-			name: "no SPDX licenses",
-			input: pkg.Package{
-				Licenses: []string{
-					"made-up",
-				},
-			},
-			expected: "NOASSERTION",
-		},
-		{
-			name: "with SPDX license",
-			input: pkg.Package{
-				Licenses: []string{
-					"MIT",
-				},
-			},
-			expected: "MIT",
-		},
-		{
-			name: "with SPDX license expression",
-			input: pkg.Package{
-				Licenses: []string{
-					"MIT",
-					"GPL-3.0",
-				},
-			},
-			expected: "MIT AND GPL-3.0",
-		},
-		{
-			name: "cap insensitive",
-			input: pkg.Package{
-				Licenses: []string{
-					"gpl-3.0",
-				},
-			},
-			expected: "GPL-3.0",
-		},
-		{
-			name: "debian to spdx conversion",
-			input: pkg.Package{
-				Licenses: []string{
-					"GPL-2",
-				},
-			},
-			expected: "GPL-2.0",
-		},
-	}
-	for _, test := range tests {
-		t.Run(test.name, func(t *testing.T) {
-			assert.Equal(t, test.expected, License(test.input))
-		})
-	}
-}
@@ -1,12 +0,0 @@
-package spdxhelpers
-
-import (
-	"strings"
-)
-
-func NoneIfEmpty(value string) string {
-	if strings.TrimSpace(value) == "" {
-		return "NONE"
-	}
-	return value
-}
@@ -1,41 +0,0 @@
-package spdxhelpers
-
-import (
-	"testing"
-
-	"github.com/stretchr/testify/assert"
-)
-
-func Test_noneIfEmpty(t *testing.T) {
-	tests := []struct {
-		name     string
-		value    string
-		expected string
-	}{
-		{
-			name:     "non-zero value",
-			value:    "something",
-			expected: "something",
-		},
-		{
-			name:     "empty",
-			value:    "",
-			expected: "NONE",
-		},
-		{
-			name:     "space",
-			value:    " ",
-			expected: "NONE",
-		},
-		{
-			name:     "tab",
-			value:    "\t",
-			expected: "NONE",
-		},
-	}
-	for _, test := range tests {
-		t.Run(test.name, func(t *testing.T) {
-			assert.Equal(t, test.expected, NoneIfEmpty(test.value))
-		})
-	}
-}
@@ -1,114 +0,0 @@
-package spdxhelpers
-
-import (
-	"testing"
-
-	"github.com/anchore/syft/syft/pkg"
-	"github.com/stretchr/testify/assert"
-)
-
-func Test_Originator(t *testing.T) {
-	tests := []struct {
-		name     string
-		input    pkg.Package
-		expected string
-	}{
-		{
-			// note: since this is an optional field, no value is preferred over NONE or NOASSERTION
-			name:     "no metadata",
-			input:    pkg.Package{},
-			expected: "",
-		},
-		{
-			name: "from gem",
-			input: pkg.Package{
-				Metadata: pkg.GemMetadata{
-					Authors: []string{
-						"auth1",
-						"auth2",
-					},
-				},
-			},
-			expected: "auth1",
-		},
-		{
-			name: "from npm",
-			input: pkg.Package{
-				Metadata: pkg.NpmPackageJSONMetadata{
-					Author: "auth",
-				},
-			},
-			expected: "auth",
-		},
-		{
-			name: "from apk",
-			input: pkg.Package{
-				Metadata: pkg.ApkMetadata{
-					Maintainer: "auth",
-				},
-			},
-			expected: "auth",
-		},
-		{
-			name: "from python - just name",
-			input: pkg.Package{
-				Metadata: pkg.PythonPackageMetadata{
-					Author: "auth",
-				},
-			},
-			expected: "auth",
-		},
-		{
-			name: "from python - just email",
-			input: pkg.Package{
-				Metadata: pkg.PythonPackageMetadata{
-					AuthorEmail: "auth@auth.gov",
-				},
-			},
-			expected: "auth@auth.gov",
-		},
-		{
-			name: "from python - both name and email",
-			input: pkg.Package{
-				Metadata: pkg.PythonPackageMetadata{
-					Author:      "auth",
-					AuthorEmail: "auth@auth.gov",
-				},
-			},
-			expected: "auth <auth@auth.gov>",
-		},
-		{
-			name: "from rpm",
-			input: pkg.Package{
-				Metadata: pkg.RpmdbMetadata{
-					Vendor: "auth",
-				},
-			},
-			expected: "auth",
-		},
-		{
-			name: "from dpkg",
-			input: pkg.Package{
-				Metadata: pkg.DpkgMetadata{
-					Maintainer: "auth",
-				},
-			},
-			expected: "auth",
-		},
-		{
-			// note: since this is an optional field, no value is preferred over NONE or NOASSERTION
-			name: "empty",
-			input: pkg.Package{
-				Metadata: pkg.NpmPackageJSONMetadata{
-					Author: "",
-				},
-			},
-			expected: "",
-		},
-	}
-	for _, test := range tests {
-		t.Run(test.name, func(t *testing.T) {
-			assert.Equal(t, test.expected, Originator(test.input))
-		})
-	}
-}
@@ -1,37 +0,0 @@
-package spdxhelpers
-
-import (
-	"fmt"
-
-	"github.com/anchore/syft/syft/pkg"
-)
-
-func Originator(p pkg.Package) string {
-	if hasMetadata(p) {
-		switch metadata := p.Metadata.(type) {
-		case pkg.ApkMetadata:
-			return metadata.Maintainer
-		case pkg.NpmPackageJSONMetadata:
-			return metadata.Author
-		case pkg.PythonPackageMetadata:
-			author := metadata.Author
-			if author == "" {
-				return metadata.AuthorEmail
-			}
-			if metadata.AuthorEmail != "" {
-				author += fmt.Sprintf(" <%s>", metadata.AuthorEmail)
-			}
-			return author
-		case pkg.GemMetadata:
-			if len(metadata.Authors) > 0 {
-				return metadata.Authors[0]
-			}
-			return ""
-		case pkg.RpmdbMetadata:
-			return metadata.Vendor
-		case pkg.DpkgMetadata:
-			return metadata.Maintainer
-		}
-	}
-	return ""
-}
@@ -1,41 +0,0 @@
-package spdxhelpers
-
-import (
-	"strings"
-
-	"github.com/anchore/syft/syft/pkg"
-)
-
-func SourceInfo(p pkg.Package) string {
-	answer := ""
-	switch p.Type {
-	case pkg.RpmPkg:
-		answer = "acquired package info from RPM DB"
-	case pkg.ApkPkg:
-		answer = "acquired package info from APK DB"
-	case pkg.DebPkg:
-		answer = "acquired package info from DPKG DB"
-	case pkg.NpmPkg:
-		answer = "acquired package info from installed node module manifest file"
-	case pkg.PythonPkg:
-		answer = "acquired package info from installed python package manifest file"
-	case pkg.JavaPkg, pkg.JenkinsPluginPkg:
-		answer = "acquired package info from installed java archive"
-	case pkg.GemPkg:
-		answer = "acquired package info from installed gem metadata file"
-	case pkg.GoModulePkg:
-		answer = "acquired package info from go module information"
-	case pkg.RustPkg:
-		answer = "acquired package info from rust cargo manifest"
-	case pkg.PhpComposerPkg:
-		answer = "acquired package info from PHP composer manifest"
-	default:
-		answer = "acquired package info from the following paths"
-	}
-	var paths []string
-	for _, l := range p.Locations {
-		paths = append(paths, l.RealPath)
-	}
-
-	return answer + ": " + strings.Join(paths, ", ")
-}
@@ -1,143 +0,0 @@
-package spdxhelpers
-
-import (
-	"testing"
-
-	"github.com/anchore/syft/syft/pkg"
-	"github.com/anchore/syft/syft/source"
-	"github.com/stretchr/testify/assert"
-)
-
-func Test_SourceInfo(t *testing.T) {
-	tests := []struct {
-		name     string
-		input    pkg.Package
-		expected []string
-	}{
-		{
-			name: "locations are captured",
-			input: pkg.Package{
-				// note: no type given
-				Locations: []source.Location{
-					source.NewVirtualLocation("/a-place", "/b-place"),
-					source.NewVirtualLocation("/c-place", "/d-place"),
-				},
-			},
-			expected: []string{
-				"from the following paths",
-				"/a-place",
-				"/c-place",
-			},
-		},
-		{
-			// note: no specific support for this
-			input: pkg.Package{
-				Type: pkg.KbPkg,
-			},
-			expected: []string{
-				"from the following paths",
-			},
-		},
-		{
-			input: pkg.Package{
-				Type: pkg.RpmPkg,
-			},
-			expected: []string{
-				"from RPM DB",
-			},
-		},
-		{
-			input: pkg.Package{
-				Type: pkg.ApkPkg,
-			},
-			expected: []string{
-				"from APK DB",
-			},
-		},
-		{
-			input: pkg.Package{
-				Type: pkg.DebPkg,
-			},
-			expected: []string{
-				"from DPKG DB",
-			},
-		},
-		{
-			input: pkg.Package{
-				Type: pkg.NpmPkg,
-			},
-			expected: []string{
-				"from installed node module manifest file",
-			},
-		},
-		{
-			input: pkg.Package{
-				Type: pkg.PythonPkg,
-			},
-			expected: []string{
-				"from installed python package manifest file",
-			},
-		},
-		{
-			input: pkg.Package{
-				Type: pkg.JavaPkg,
-			},
-			expected: []string{
-				"from installed java archive",
-			},
-		},
-		{
-			input: pkg.Package{
-				Type: pkg.JenkinsPluginPkg,
-			},
-			expected: []string{
-				"from installed java archive",
-			},
-		},
-		{
-			input: pkg.Package{
-				Type: pkg.GemPkg,
-			},
-			expected: []string{
-				"from installed gem metadata file",
-			},
-		},
-		{
-			input: pkg.Package{
-				Type: pkg.GoModulePkg,
-			},
-			expected: []string{
-				"from go module information",
-			},
-		},
-		{
-			input: pkg.Package{
-				Type: pkg.RustPkg,
-			},
-			expected: []string{
-				"from rust cargo manifest",
-			},
-		},
-		{
-			input: pkg.Package{
-				Type: pkg.PhpComposerPkg,
-			},
-			expected: []string{
-				"from PHP composer manifest",
-			},
-		},
-	}
-	var pkgTypes []pkg.Type
-	for _, test := range tests {
-		t.Run(test.name+" "+string(test.input.Type), func(t *testing.T) {
-			if test.input.Type != "" {
-				pkgTypes = append(pkgTypes, test.input.Type)
-			}
-			actual := SourceInfo(test.input)
-			for _, expected := range test.expected {
-				assert.Contains(t, actual, expected)
-			}
-		})
-	}
-	assert.ElementsMatch(t, pkg.AllPkgs, pkgTypes, "missing one or more package types to test against (maybe a package type was added?)")
-}
@@ -1,26 +0,0 @@
-package cyclonedx12xml
-
-import (
-	"encoding/xml"
-	"io"
-
-	"github.com/anchore/syft/syft/sbom"
-)
-
-func encoder(output io.Writer, s sbom.SBOM) error {
-	enc := xml.NewEncoder(output)
-	enc.Indent("", "  ")
-
-	_, err := output.Write([]byte(xml.Header))
-	if err != nil {
-		return err
-	}
-
-	err = enc.Encode(toFormatModel(s))
-	if err != nil {
-		return err
-	}
-
-	_, err = output.Write([]byte("\n"))
-	return err
-}
@@ -1,12 +0,0 @@
-package cyclonedx12xml
-
-import "github.com/anchore/syft/syft/format"
-
-func Format() format.Format {
-	return format.NewFormat(
-		format.CycloneDxOption,
-		encoder,
-		nil,
-		nil,
-	)
-}
@@ -1,31 +0,0 @@
-package model
-
-import (
-	"encoding/xml"
-)
-
-// Source: https://cyclonedx.org/ext/bom-descriptor/
-
-// BomDescriptor represents all metadata surrounding the BOM report (such as when the BOM was made, with which tool, and the item being cataloged).
-type BomDescriptor struct {
-	XMLName   xml.Name                `xml:"metadata"`
-	Timestamp string                  `xml:"timestamp,omitempty"` // The date and time (timestamp) when the document was created
-	Tools     []BomDescriptorTool     `xml:"tools>tool"`          // The tool used to create the BOM.
-	Component *BomDescriptorComponent `xml:"component"`           // The component that the BOM describes.
-}
-
-// BomDescriptorTool represents the tool that created the BOM report.
-type BomDescriptorTool struct {
-	XMLName xml.Name `xml:"tool"`
-	Vendor  string   `xml:"vendor,omitempty"`  // The vendor of the tool used to create the BOM.
-	Name    string   `xml:"name,omitempty"`    // The name of the tool used to create the BOM.
-	Version string   `xml:"version,omitempty"` // The version of the tool used to create the BOM.
-	// TODO: hashes, author, manufacture, supplier
-	// TODO: add user-defined fields for the remaining build/version parameters
-}
-
-// BomDescriptorComponent represents the software/package being cataloged.
-type BomDescriptorComponent struct {
-	XMLName xml.Name `xml:"component"`
-	Component
-}
@@ -1,20 +0,0 @@
-package model
-
-import "encoding/xml"
-
-// Component represents a single element in the CycloneDX BOM
-type Component struct {
-	XMLName     xml.Name   `xml:"component"`
-	Type        string     `xml:"type,attr"`             // Required; Describes if the component is a library, framework, application, container, operating system, firmware, hardware device, or file
-	Supplier    string     `xml:"supplier,omitempty"`    // The organization that supplied the component. The supplier may often be the manufacture, but may also be a distributor or repackager.
-	Author      string     `xml:"author,omitempty"`      // The person(s) or organization(s) that authored the component
-	Publisher   string     `xml:"publisher,omitempty"`   // The person(s) or organization(s) that published the component
-	Group       string     `xml:"group,omitempty"`       // The high-level classification that a project self-describes as. This will often be a shortened, single name of the company or project that produced the component, or the source package or domain name.
-	Name        string     `xml:"name"`                  // Required; The name of the component as defined by the project
-	Version     string     `xml:"version"`               // Required; The version of the component as defined by the project
-	Description string     `xml:"description,omitempty"` // A description of the component
-	Licenses    *[]License `xml:"licenses>license"`      // A node describing zero or more license names, SPDX license IDs or expressions
-	PackageURL  string     `xml:"purl,omitempty"`        // Specifies the package-url (PackageURL). The purl, if specified, must be valid and conform to the specification defined at: https://github.com/package-url/purl-spec
-	// TODO: source, hashes, copyright, cpe, purl, swid, modified, pedigree, externalReferences
-	// TODO: add user-defined parameters for syft-specific values (image layer index, cataloger, location path, etc.)
-}
@@ -1,17 +0,0 @@
-package model
-
-import (
-	"encoding/xml"
-)
-
-// Source: https://github.com/CycloneDX/specification
-
-// Document represents a CycloneDX BOM Document.
-type Document struct {
-	XMLName       xml.Name       `xml:"bom"`
-	XMLNs         string         `xml:"xmlns,attr"`
-	Version       int            `xml:"version,attr"`
-	SerialNumber  string         `xml:"serialNumber,attr"`
-	BomDescriptor *BomDescriptor `xml:"metadata"`             // The BOM descriptor extension
-	Components    []Component    `xml:"components>component"` // The BOM contents
-}
@@ -1,10 +0,0 @@
-package model
-
-import "encoding/xml"
-
-// License represents a single software license for a Component
-type License struct {
-	XMLName xml.Name `xml:"license"`
-	ID      string   `xml:"id,omitempty"`   // A valid SPDX license ID
-	Name    string   `xml:"name,omitempty"` // If SPDX does not define the license used, this field may be used to provide the license name
-}
@@ -1,95 +0,0 @@
-package cyclonedx12xml
-
-import (
-	"encoding/xml"
-	"time"
-
-	"github.com/anchore/syft/syft/sbom"
-
-	"github.com/anchore/syft/internal"
-	"github.com/anchore/syft/internal/formats/cyclonedx12xml/model"
-	"github.com/anchore/syft/internal/version"
-	"github.com/anchore/syft/syft/pkg"
-	"github.com/anchore/syft/syft/source"
-	"github.com/google/uuid"
-)
-
-// toFormatModel creates and populates a new in-memory representation of a CycloneDX 1.2 document
-func toFormatModel(s sbom.SBOM) model.Document {
-	versionInfo := version.FromBuild()
-
-	doc := model.Document{
-		XMLNs:         "http://cyclonedx.org/schema/bom/1.2",
-		Version:       1,
-		SerialNumber:  uuid.New().URN(),
-		BomDescriptor: toBomDescriptor(internal.ApplicationName, versionInfo.Version, s.Source),
-	}
-
-	// attach components
-	for _, p := range s.Artifacts.PackageCatalog.Sorted() {
-		doc.Components = append(doc.Components, toComponent(p))
-	}
-
-	return doc
-}
-
-func toComponent(p pkg.Package) model.Component {
-	return model.Component{
-		Type:       "library", // TODO: this is not accurate
-		Name:       p.Name,
-		Version:    p.Version,
-		PackageURL: p.PURL,
-		Licenses:   toLicenses(p.Licenses),
-	}
-}
-
-// NewBomDescriptor returns a new BomDescriptor tailored for the current time and "syft" tool details.
-func toBomDescriptor(name, version string, srcMetadata source.Metadata) *model.BomDescriptor {
-	return &model.BomDescriptor{
-		XMLName:   xml.Name{},
-		Timestamp: time.Now().Format(time.RFC3339),
-		Tools: []model.BomDescriptorTool{
-			{
-				Vendor:  "anchore",
-				Name:    name,
-				Version: version,
-			},
-		},
-		Component: toBomDescriptorComponent(srcMetadata),
-	}
-}
-
-func toBomDescriptorComponent(srcMetadata source.Metadata) *model.BomDescriptorComponent {
-	switch srcMetadata.Scheme {
-	case source.ImageScheme:
-		return &model.BomDescriptorComponent{
-			Component: model.Component{
-				Type:    "container",
-				Name:    srcMetadata.ImageMetadata.UserInput,
-				Version: srcMetadata.ImageMetadata.ManifestDigest,
-			},
-		}
-	case source.DirectoryScheme:
-		return &model.BomDescriptorComponent{
-			Component: model.Component{
-				Type: "file",
-				Name: srcMetadata.Path,
-			},
-		}
-	}
-	return nil
-}
-
-func toLicenses(licenses []string) *[]model.License {
-	if len(licenses) == 0 {
-		return nil
-	}
-
-	var result []model.License
-	for _, licenseName := range licenses {
-		result = append(result, model.License{
-			Name: licenseName,
-		})
-	}
-	return &result
-}
@@ -1,44 +0,0 @@
-package formats
-
-import (
-	"bytes"
-
-	"github.com/anchore/syft/internal/formats/cyclonedx12xml"
-	"github.com/anchore/syft/internal/formats/spdx22json"
-	"github.com/anchore/syft/internal/formats/spdx22tagvalue"
-	"github.com/anchore/syft/internal/formats/syftjson"
-	"github.com/anchore/syft/internal/formats/table"
-	"github.com/anchore/syft/internal/formats/text"
-	"github.com/anchore/syft/syft/format"
-)
-
-// TODO: eventually this is the source of truth for all formatters
-func All() []format.Format {
-	return []format.Format{
-		syftjson.Format(),
-		table.Format(),
-		cyclonedx12xml.Format(),
-		spdx22json.Format(),
-		spdx22tagvalue.Format(),
-		text.Format(),
-	}
-}
-
-func Identify(by []byte) (*format.Format, error) {
-	for _, f := range All() {
-		if err := f.Validate(bytes.NewReader(by)); err != nil {
-			continue
-		}
-		return &f, nil
-	}
-	return nil, nil
-}
-
-func ByOption(option format.Option) *format.Format {
-	for _, f := range All() {
-		if f.Option == option {
-			return &f
-		}
-	}
-	return nil
-}
@@ -1,34 +0,0 @@
-package formats
-
-import (
-	"io"
-	"os"
-	"testing"
-
-	"github.com/anchore/syft/syft/format"
-	"github.com/stretchr/testify/assert"
-)
-
-func TestIdentify(t *testing.T) {
-	tests := []struct {
-		fixture  string
-		expected format.Option
-	}{
-		{
-			fixture:  "test-fixtures/alpine-syft.json",
-			expected: format.JSONOption,
-		},
-	}
-	for _, test := range tests {
-		t.Run(test.fixture, func(t *testing.T) {
-			f, err := os.Open(test.fixture)
-			assert.NoError(t, err)
-			by, err := io.ReadAll(f)
-			assert.NoError(t, err)
-			frmt, err := Identify(by)
-			assert.NoError(t, err)
-			assert.NotNil(t, frmt)
-			assert.Equal(t, test.expected, frmt.Option)
-		})
-	}
-}
@@ -1,21 +0,0 @@
-package spdx22json
-
-import (
-	"encoding/json"
-	"io"
-
-	"github.com/anchore/syft/syft/sbom"
-)
-
-const anchoreNamespace = "https://anchore.com/syft"
-
-func encoder(output io.Writer, s sbom.SBOM) error {
-	doc := toFormatModel(s)
-
-	enc := json.NewEncoder(output)
-	// prevent > and < from being escaped in the payload
-	enc.SetEscapeHTML(false)
-	enc.SetIndent("", " ")
-
-	return enc.Encode(&doc)
-}
@@ -1,13 +0,0 @@
-package spdx22json
-
-import "github.com/anchore/syft/syft/format"
-
-// note: this format is LOSSY relative to the syftjson formation, which means that decoding and validation is not supported at this time
-func Format() format.Format {
-	return format.NewFormat(
-		format.SPDXJSONOption,
-		encoder,
-		nil,
-		nil,
-	)
-}
@@ -1,4 +0,0 @@
-# Note: changes to this file will result in updating several test values. Consider making a new image fixture instead of editing this one.
-FROM scratch
-ADD file-1.txt /somefile-1.txt
-ADD file-2.txt /somefile-2.txt
@@ -1 +0,0 @@
-this file has contents
@@ -1 +0,0 @@
-file-2 contents!
@@ -1,266 +0,0 @@
-package spdx22json
-
-import (
-	"fmt"
-	"path"
-	"path/filepath"
-	"sort"
-	"strings"
-	"time"
-
-	"github.com/anchore/syft/internal"
-	"github.com/anchore/syft/internal/formats/common/spdxhelpers"
-	"github.com/anchore/syft/internal/formats/spdx22json/model"
-	"github.com/anchore/syft/internal/log"
-	"github.com/anchore/syft/internal/spdxlicense"
-	"github.com/anchore/syft/internal/version"
-	"github.com/anchore/syft/syft/artifact"
-	"github.com/anchore/syft/syft/file"
-	"github.com/anchore/syft/syft/pkg"
-	"github.com/anchore/syft/syft/sbom"
-	"github.com/anchore/syft/syft/source"
-	"github.com/google/uuid"
-)
-
-// toFormatModel creates and populates a new JSON document struct that follows the SPDX 2.2 spec from the given cataloging results.
-func toFormatModel(s sbom.SBOM) model.Document {
-	name := documentName(s.Source)
-
-	return model.Document{
-		Element: model.Element{
-			SPDXID: model.ElementID("DOCUMENT").String(),
-			Name:   name,
-		},
-		SPDXVersion: model.Version,
-		CreationInfo: model.CreationInfo{
-			Created: time.Now().UTC(),
-			Creators: []string{
-				// note: key-value format derived from the JSON example document examples: https://github.com/spdx/spdx-spec/blob/v2.2/examples/SPDXJSONExample-v2.2.spdx.json
-				"Organization: Anchore, Inc",
-				"Tool: " + internal.ApplicationName + "-" + version.FromBuild().Version,
-			},
-			LicenseListVersion: spdxlicense.Version,
-		},
-		DataLicense:       "CC0-1.0",
-		DocumentNamespace: documentNamespace(name, s.Source),
-		Packages:          toPackages(s.Artifacts.PackageCatalog, s.Relationships),
-		Files:             toFiles(s),
-		Relationships:     toRelationships(s.Relationships),
-	}
-}
-
-func documentName(srcMetadata source.Metadata) string {
-	switch srcMetadata.Scheme {
-	case source.ImageScheme:
-		return cleanSPDXName(srcMetadata.ImageMetadata.UserInput)
-	case source.DirectoryScheme:
-		return cleanSPDXName(srcMetadata.Path)
-	}
-
-	// TODO: is this alright?
-	return uuid.Must(uuid.NewRandom()).String()
-}
-
-func cleanSPDXName(name string) string {
-	// remove # according to specification
-	name = strings.ReplaceAll(name, "#", "-")
-
-	// remove : for url construction
-	name = strings.ReplaceAll(name, ":", "-")
-
-	// clean relative pathing
-	return path.Clean(name)
-}
-
-func documentNamespace(name string, srcMetadata source.Metadata) string {
-	input := "unknown-source-type"
-	switch srcMetadata.Scheme {
-	case source.ImageScheme:
-		input = "image"
-	case source.DirectoryScheme:
-		input = "dir"
-	}
-
-	uniqueID := uuid.Must(uuid.NewRandom())
-	identifier := path.Join(input, uniqueID.String())
-	if name != "." {
-		identifier = path.Join(input, fmt.Sprintf("%s-%s", name, uniqueID.String()))
-	}
-
-	return path.Join(anchoreNamespace, identifier)
-}
-
-func toPackages(catalog *pkg.Catalog, relationships []artifact.Relationship) []model.Package {
-	packages := make([]model.Package, 0)
-
-	for _, p := range catalog.Sorted() {
-		license := spdxhelpers.License(p)
-		packageSpdxID := model.ElementID(p.ID()).String()
-
-		// note: the license concluded and declared should be the same since we are collecting license information
-		// from the project data itself (the installed package files).
-		packages = append(packages, model.Package{
-			Description:      spdxhelpers.Description(p),
-			DownloadLocation: spdxhelpers.DownloadLocation(p),
-			ExternalRefs:     spdxhelpers.ExternalRefs(p),
-			FilesAnalyzed:    false,
-			HasFiles:         fileIDsForPackage(packageSpdxID, relationships),
-			Homepage:         spdxhelpers.Homepage(p),
-			// The Declared License is what the authors of a project believe govern the package
-			LicenseDeclared: license,
-			Originator:      spdxhelpers.Originator(p),
-			SourceInfo:      spdxhelpers.SourceInfo(p),
-			VersionInfo:     p.Version,
-			Item: model.Item{
-				// The Concluded License field is the license the SPDX file creator believes governs the package
-				LicenseConcluded: license,
-				Element: model.Element{
-					SPDXID: packageSpdxID,
-					Name:   p.Name,
-				},
-			},
-		})
-	}
-
-	return packages
-}
-
-func fileIDsForPackage(packageSpdxID string, relationships []artifact.Relationship) (fileIDs []string) {
-	for _, relationship := range relationships {
-		if relationship.Type != artifact.ContainsRelationship {
-			continue
-		}
-
-		if _, ok := relationship.From.(pkg.Package); !ok {
-			continue
-		}
-
-		if _, ok := relationship.To.(source.Coordinates); !ok {
-			continue
-		}
-
-		if string(relationship.From.ID()) == packageSpdxID {
-			fileIDs = append(fileIDs, string(relationship.To.ID()))
-		}
-	}
-	return fileIDs
-}
-
-func toFiles(s sbom.SBOM) []model.File {
-	results := make([]model.File, 0)
-	artifacts := s.Artifacts
-
-	for _, coordinates := range sbom.AllCoordinates(s) {
-		var metadata *source.FileMetadata
-		if metadataForLocation, exists := artifacts.FileMetadata[coordinates]; exists {
-			metadata = &metadataForLocation
-		}
-
-		var digests []file.Digest
-		if digestsForLocation, exists := artifacts.FileDigests[coordinates]; exists {
-			digests = digestsForLocation
-		}
-
-		// TODO: add file classifications (?) and content as a snippet
-
-		var comment string
-		if coordinates.FileSystemID != "" {
-			comment = fmt.Sprintf("layerID: %s", coordinates.FileSystemID)
-		}
-
-		results = append(results, model.File{
-			Item: model.Item{
-				Element: model.Element{
-					SPDXID:  string(coordinates.ID()),
-					Name:    filepath.Base(coordinates.RealPath),
-					Comment: comment,
-				},
-				// required, no attempt made to determine license information
-				LicenseConcluded: "NOASSERTION",
-			},
-			Checksums: toFileChecksums(digests),
-			FileName:  coordinates.RealPath,
-			FileTypes: toFileTypes(metadata),
-		})
-	}
-
-	// sort by real path then virtual path to ensure the result is stable across multiple runs
-	sort.SliceStable(results, func(i, j int) bool {
-		return results[i].FileName < results[j].FileName
-	})
-	return results
-}
-
-func toFileChecksums(digests []file.Digest) (checksums []model.Checksum) {
-	for _, digest := range digests {
-		checksums = append(checksums, model.Checksum{
-			Algorithm:     digest.Algorithm,
-			ChecksumValue: digest.Value,
-		})
-	}
-	return checksums
-}
-
-func toFileTypes(metadata *source.FileMetadata) (ty []string) {
-	if metadata == nil {
-		return nil
-	}
-
-	mimeTypePrefix := strings.Split(metadata.MIMEType, "/")[0]
-	switch mimeTypePrefix {
-	case "image":
-		ty = append(ty, string(model.ImageFileType))
-	case "video":
-		ty = append(ty, string(model.VideoFileType))
-	case "application":
-		ty = append(ty, string(model.ApplicationFileType))
-	case "text":
-		ty = append(ty, string(model.TextFileType))
-	case "audio":
-		ty = append(ty, string(model.AudioFileType))
-	}
-
-	if internal.IsExecutable(metadata.MIMEType) {
-		ty = append(ty, string(model.BinaryFileType))
-	}
-
-	if internal.IsArchive(metadata.MIMEType) {
-		ty = append(ty, string(model.ArchiveFileType))
-	}
-
-	// TODO: add support for source, spdx, and documentation file types
-	if len(ty) == 0 {
-		ty = append(ty, string(model.OtherFileType))
-	}
-
-	return ty
-}
-
-func toRelationships(relationships []artifact.Relationship) (result []model.Relationship) {
-	for _, r := range relationships {
-		exists, relationshipType, comment := lookupRelationship(r.Type)
-
-		if !exists {
-			log.Warnf("unable to convert relationship from SPDX 2.2 JSON, dropping: %+v", r)
-			continue
-		}
-
-		result = append(result, model.Relationship{
-			SpdxElementID:      string(r.From.ID()),
-			RelationshipType:   relationshipType,
-			RelatedSpdxElement: string(r.To.ID()),
-			Comment:            comment,
-		})
-	}
-	return result
-}
-
-func lookupRelationship(ty artifact.RelationshipType) (bool, model.RelationshipType, string) {
-	switch ty {
-	case artifact.ContainsRelationship:
-		return true, model.ContainsRelationship, ""
-	case artifact.OwnershipByFileOverlapRelationship:
-		return true, model.OtherRelationship, fmt.Sprintf("%s: indicates that the parent package claims ownership of a child package since the parent metadata indicates overlap with a location that a cataloger found the child package by", ty)
-	}
-	return false, "", ""
-}
@@ -1,256 +0,0 @@
-package spdx22json
-
-import (
-	"testing"
-
-	"github.com/anchore/syft/syft/pkg"
-
-	"github.com/anchore/syft/syft/file"
-
-	"github.com/anchore/syft/syft/artifact"
-
-	"github.com/anchore/syft/internal/formats/spdx22json/model"
-	"github.com/anchore/syft/syft/source"
-	"github.com/stretchr/testify/assert"
-)
-
-func Test_toFileTypes(t *testing.T) {
-
-	tests := []struct {
-		name     string
-		metadata source.FileMetadata
-		expected []string
-	}{
-		{
-			name: "application",
-			metadata: source.FileMetadata{
-				MIMEType: "application/vnd.unknown",
-			},
-			expected: []string{
-				string(model.ApplicationFileType),
-			},
-		},
-		{
-			name: "archive",
-			metadata: source.FileMetadata{
-				MIMEType: "application/zip",
-			},
-			expected: []string{
-				string(model.ApplicationFileType),
-				string(model.ArchiveFileType),
-			},
-		},
-		{
-			name: "audio",
-			metadata: source.FileMetadata{
-				MIMEType: "audio/ogg",
-			},
-			expected: []string{
-				string(model.AudioFileType),
-			},
-		},
-		{
-			name: "video",
-			metadata: source.FileMetadata{
-				MIMEType: "video/3gpp",
-			},
-			expected: []string{
-				string(model.VideoFileType),
-			},
-		},
-		{
-			name: "text",
-			metadata: source.FileMetadata{
-				MIMEType: "text/html",
-			},
-			expected: []string{
-				string(model.TextFileType),
-			},
-		},
-		{
-			name: "image",
-			metadata: source.FileMetadata{
-				MIMEType: "image/png",
-			},
-			expected: []string{
-				string(model.ImageFileType),
-			},
-		},
-		{
-			name: "binary",
-			metadata: source.FileMetadata{
-				MIMEType: "application/x-sharedlib",
-			},
-			expected: []string{
-				string(model.ApplicationFileType),
-				string(model.BinaryFileType),
-			},
-		},
-	}
-	for _, test := range tests {
-		t.Run(test.name, func(t *testing.T) {
-			assert.ElementsMatch(t, test.expected, toFileTypes(&test.metadata))
-		})
-	}
-}
-
-func Test_lookupRelationship(t *testing.T) {
-
-	tests := []struct {
-		input   artifact.RelationshipType
-		exists  bool
-		ty      model.RelationshipType
-		comment string
-	}{
-		{
-			input:  artifact.ContainsRelationship,
-			exists: true,
-			ty:     model.ContainsRelationship,
-		},
-		{
-			input:   artifact.OwnershipByFileOverlapRelationship,
-			exists:  true,
-			ty:      model.OtherRelationship,
-			comment: "ownership-by-file-overlap: indicates that the parent package claims ownership of a child package since the parent metadata indicates overlap with a location that a cataloger found the child package by",
-		},
-		{
-			input:  "made-up",
-			exists: false,
-		},
-	}
-	for _, test := range tests {
-		t.Run(string(test.input), func(t *testing.T) {
-			exists, ty, comment := lookupRelationship(test.input)
-			assert.Equal(t, exists, test.exists)
-			assert.Equal(t, ty, test.ty)
-			assert.Equal(t, comment, test.comment)
-		})
-	}
-}
-
-func Test_toFileChecksums(t *testing.T) {
-	tests := []struct {
-		name     string
-		digests  []file.Digest
-		expected []model.Checksum
-	}{
-		{
-			name: "empty",
-		},
-		{
-			name: "has digests",
-			digests: []file.Digest{
-				{
-					Algorithm: "sha256",
-					Value:     "deadbeefcafe",
-				},
-				{
-					Algorithm: "md5",
-					Value:     "meh",
-				},
-			},
-			expected: []model.Checksum{
-				{
-					Algorithm:     "sha256",
-					ChecksumValue: "deadbeefcafe",
-				},
-				{
-					Algorithm:     "md5",
-					ChecksumValue: "meh",
-				},
-			},
-		},
-	}
-	for _, test := range tests {
-		t.Run(test.name, func(t *testing.T) {
-			assert.ElementsMatch(t, test.expected, toFileChecksums(test.digests))
-		})
-	}
-}
-
-func Test_fileIDsForPackage(t *testing.T) {
-
-	p := pkg.Package{
-		Name: "bogus",
-	}
-
-	c := source.Coordinates{
-		RealPath:     "/path",
-		FileSystemID: "nowhere",
-	}
-
-	tests := []struct {
-		name          string
-		id            string
-		relationships []artifact.Relationship
-		expected      []string
-	}{
-		{
-			name: "find file IDs for packages with package-file relationships",
-			id:   string(p.ID()),
-			relationships: []artifact.Relationship{
-				{
-					From: p,
-					To:   c,
-					Type: artifact.ContainsRelationship,
-				},
-			},
-			expected: []string{
-				string(c.ID()),
-			},
-		},
-		{
-			name: "ignore package-to-package",
-			id:   string(p.ID()),
-			relationships: []artifact.Relationship{
-				{
-					From: p,
-					To:   p,
-					Type: artifact.ContainsRelationship,
-				},
-			},
-			expected: []string{},
-		},
-		{
-			name: "ignore file-to-file",
-			id:   string(p.ID()),
-			relationships: []artifact.Relationship{
-				{
-					From: c,
-					To:   c,
-					Type: artifact.ContainsRelationship,
-				},
-			},
-			expected: []string{},
-		},
-		{
-			name: "ignore file-to-package",
-			id:   string(p.ID()),
-			relationships: []artifact.Relationship{
-				{
-					From: c,
-					To:   p,
-					Type: artifact.ContainsRelationship,
-				},
-			},
-			expected: []string{},
-		},
-		{
-			name: "filter by relationship type",
-			id:   string(p.ID()),
-			relationships: []artifact.Relationship{
-				{
-					From: p,
-					To:   c,
-					Type: artifact.OwnershipByFileOverlapRelationship,
-				},
-			},
-			expected: []string{},
-		},
-	}
-	for _, test := range tests {
-		t.Run(test.name, func(t *testing.T) {
-			assert.ElementsMatch(t, test.expected, fileIDsForPackage(test.id, test.relationships))
-		})
-	}
-}
@@ -1,13 +0,0 @@
-package spdx22tagvalue
-
-import (
-	"io"
-
-	"github.com/anchore/syft/syft/sbom"
-	"github.com/spdx/tools-golang/tvsaver"
-)
-
-func encoder(output io.Writer, s sbom.SBOM) error {
-	model := toFormatModel(s)
-	return tvsaver.Save2_2(&model, output)
-}
@@ -1,13 +0,0 @@
-package spdx22tagvalue
-
-import "github.com/anchore/syft/syft/format"
-
-// note: this format is LOSSY relative to the syftjson formation, which means that decoding and validation is not supported at this time
-func Format() format.Format {
-	return format.NewFormat(
-		format.SPDXTagValueOption,
-		encoder,
-		nil,
-		nil,
-	)
-}
@@ -1,4 +0,0 @@
-# Note: changes to this file will result in updating several test values. Consider making a new image fixture instead of editing this one.
-FROM scratch
-ADD file-1.txt /somefile-1.txt
-ADD file-2.txt /somefile-2.txt
@@ -1 +0,0 @@
-this file has contents
@@ -1 +0,0 @@
-file-2 contents!
@@ -1,23 +0,0 @@
-package syftjson
-
-import (
-	"encoding/json"
-	"fmt"
-	"io"
-
-	"github.com/anchore/syft/syft/sbom"
-
-	"github.com/anchore/syft/internal/formats/syftjson/model"
-)
-
-func decoder(reader io.Reader) (*sbom.SBOM, error) {
-	dec := json.NewDecoder(reader)
-
-	var doc model.Document
-	err := dec.Decode(&doc)
-	if err != nil {
-		return nil, fmt.Errorf("unable to decode syft-json: %w", err)
-	}
-
-	return toSyftModel(doc)
-}
@@ -1,46 +0,0 @@
-package syftjson
-
-import (
-	"bytes"
-	"strings"
-	"testing"
-
-	"github.com/anchore/syft/internal/formats/common/testutils"
-	"github.com/go-test/deep"
-	"github.com/stretchr/testify/assert"
-)
-
-func TestEncodeDecodeCycle(t *testing.T) {
-	testImage := "image-simple"
-	originalSBOM := testutils.ImageInput(t, testImage)
-
-	var buf bytes.Buffer
-	assert.NoError(t, encoder(&buf, originalSBOM))
-
-	actualSBOM, err := decoder(bytes.NewReader(buf.Bytes()))
-	assert.NoError(t, err)
-
-	for _, d := range deep.Equal(originalSBOM.Source, actualSBOM.Source) {
-		t.Errorf("metadata difference: %+v", d)
-	}
-
-	actualPackages := actualSBOM.Artifacts.PackageCatalog.Sorted()
-	for idx, p := range originalSBOM.Artifacts.PackageCatalog.Sorted() {
-		if !assert.Equal(t, p.Name, actualPackages[idx].Name) {
-			t.Errorf("different package at idx=%d: %s vs %s", idx, p.Name, actualPackages[idx].Name)
-			continue
-		}
-
-		for _, d := range deep.Equal(p, actualPackages[idx]) {
-			if strings.Contains(d, ".VirtualPath: ") {
-				// location.Virtual path is not exposed in the json output
-				continue
-			}
-			if strings.HasSuffix(d, "<nil slice> != []") {
-				// semantically the same
-				continue
-			}
-			t.Errorf("package difference (%s): %+v", p.Name, d)
-		}
-	}
-}
@@ -1,19 +0,0 @@
-package syftjson
-
-import (
-	"encoding/json"
-	"io"
-
-	"github.com/anchore/syft/syft/sbom"
-)
-
-func encoder(output io.Writer, s sbom.SBOM) error {
-	doc := ToFormatModel(s)
-
-	enc := json.NewEncoder(output)
-	// prevent > and < from being escaped in the payload
-	enc.SetEscapeHTML(false)
-	enc.SetIndent("", " ")
-
-	return enc.Encode(&doc)
-}
@@ -1,199 +0,0 @@
-package syftjson
-
-import (
-	"flag"
-	"testing"
-
-	"github.com/anchore/syft/syft/file"
-
-	"github.com/anchore/syft/syft/artifact"
-
-	"github.com/anchore/syft/syft/distro"
-	"github.com/anchore/syft/syft/pkg"
-	"github.com/anchore/syft/syft/sbom"
-	"github.com/anchore/syft/syft/source"
-
-	"github.com/anchore/syft/internal/formats/common/testutils"
-)
-
-var updateJson = flag.Bool("update-json", false, "update the *.golden files for json presenters")
-
-func TestDirectoryPresenter(t *testing.T) {
-	testutils.AssertPresenterAgainstGoldenSnapshot(t,
-		Format().Presenter(testutils.DirectoryInput(t)),
-		*updateJson,
-	)
-}
-
-func TestImagePresenter(t *testing.T) {
-	testImage := "image-simple"
-	testutils.AssertPresenterAgainstGoldenImageSnapshot(t,
-		Format().Presenter(testutils.ImageInput(t, testImage, testutils.FromSnapshot())),
-		testImage,
-		*updateJson,
-	)
-}
-
-func TestEncodeFullJSONDocument(t *testing.T) {
-	catalog := pkg.NewCatalog()
-
-	p1 := pkg.Package{
-		Name:    "package-1",
-		Version: "1.0.1",
-		Locations: []source.Location{
-			{
-				Coordinates: source.Coordinates{
-					RealPath: "/a/place/a",
-				},
-			},
-		},
-		Type:         pkg.PythonPkg,
-		FoundBy:      "the-cataloger-1",
-		Language:     pkg.Python,
-		MetadataType: pkg.PythonPackageMetadataType,
-		Licenses:     []string{"MIT"},
-		Metadata: pkg.PythonPackageMetadata{
-			Name:    "package-1",
-			Version: "1.0.1",
-			Files:   []pkg.PythonFileRecord{},
-		},
-		PURL: "a-purl-1",
-		CPEs: []pkg.CPE{
-			pkg.MustCPE("cpe:2.3:*:some:package:1:*:*:*:*:*:*:*"),
-		},
-	}
-
-	p2 := pkg.Package{
-		Name:    "package-2",
-		Version: "2.0.1",
-		Locations: []source.Location{
-			{
-				Coordinates: source.Coordinates{
-					RealPath: "/b/place/b",
-				},
-			},
-		},
-		Type:         pkg.DebPkg,
-		FoundBy:      "the-cataloger-2",
-		MetadataType: pkg.DpkgMetadataType,
-		Metadata: pkg.DpkgMetadata{
-			Package: "package-2",
-			Version: "2.0.1",
-			Files:   []pkg.DpkgFileRecord{},
-		},
-		PURL: "a-purl-2",
-		CPEs: []pkg.CPE{
-			pkg.MustCPE("cpe:2.3:*:some:package:2:*:*:*:*:*:*:*"),
-		},
-	}
-
-	catalog.Add(p1)
-	catalog.Add(p2)
-
-	s := sbom.SBOM{
-		Artifacts: sbom.Artifacts{
-			PackageCatalog: catalog,
-			FileMetadata: map[source.Coordinates]source.FileMetadata{
-				source.NewLocation("/a/place").Coordinates: {
-					Mode:    0775,
-					Type:    "directory",
-					UserID:  0,
-					GroupID: 0,
-				},
-				source.NewLocation("/a/place/a").Coordinates: {
-					Mode:    0775,
-					Type:    "regularFile",
-					UserID:  0,
-					GroupID: 0,
-				},
-				source.NewLocation("/b").Coordinates: {
-					Mode:            0775,
-					Type:            "symbolicLink",
-					LinkDestination: "/c",
-					UserID:          0,
-					GroupID:         0,
-				},
-				source.NewLocation("/b/place/b").Coordinates: {
-					Mode:    0644,
-					Type:    "regularFile",
-					UserID:  1,
-					GroupID: 2,
-				},
-			},
-			FileDigests: map[source.Coordinates][]file.Digest{
-				source.NewLocation("/a/place/a").Coordinates: {
-					{
-						Algorithm: "sha256",
-						Value:     "366a3f5653e34673b875891b021647440d0127c2ef041e3b1a22da2a7d4f3703",
-					},
-				},
-				source.NewLocation("/b/place/b").Coordinates: {
-					{
-						Algorithm: "sha256",
-						Value:     "1b3722da2a7d90d033b87581a2a3f12021647445653e34666ef041e3b4f3707c",
-					},
-				},
-			},
-			FileContents: map[source.Coordinates]string{
-				source.NewLocation("/a/place/a").Coordinates: "the-contents",
-			},
-			Distro: &distro.Distro{
-				Type:       distro.RedHat,
-				RawVersion: "7",
-				IDLike:     "rhel",
-			},
-		},
-		Relationships: []artifact.Relationship{
-			{
-				From: p1,
-				To:   p2,
-				Type: artifact.OwnershipByFileOverlapRelationship,
-				Data: map[string]string{
-					"file": "path",
-				},
-			},
-		},
-		Source: source.Metadata{
-			Scheme: source.ImageScheme,
-			ImageMetadata: source.ImageMetadata{
-				UserInput:      "user-image-input",
-				ID:             "sha256:c2b46b4eb06296933b7cf0722683964e9ecbd93265b9ef6ae9642e3952afbba0",
-				ManifestDigest: "sha256:2731251dc34951c0e50fcc643b4c5f74922dad1a5d98f302b504cf46cd5d9368",
-				MediaType:      "application/vnd.docker.distribution.manifest.v2+json",
-				Tags: []string{
-					"stereoscope-fixture-image-simple:85066c51088bdd274f7a89e99e00490f666c49e72ffc955707cd6e18f0e22c5b",
-				},
-				Size: 38,
-				Layers: []source.LayerMetadata{
-					{
-						MediaType: "application/vnd.docker.image.rootfs.diff.tar.gzip",
-						Digest:    "sha256:3de16c5b8659a2e8d888b8ded8427be7a5686a3c8c4e4dd30de20f362827285b",
-						Size:      22,
-					},
-					{
-						MediaType: "application/vnd.docker.image.rootfs.diff.tar.gzip",
-						Digest:    "sha256:366a3f5653e34673b875891b021647440d0127c2ef041e3b1a22da2a7d4f3703",
-						Size:      16,
-					},
-				},
-				RawManifest: []byte("eyJzY2hlbWFWZXJzaW9uIjoyLCJtZWRpYVR5cGUiOiJh..."),
-				RawConfig:   []byte("eyJhcmNoaXRlY3R1cmUiOiJhbWQ2NCIsImNvbmZp..."),
-				RepoDigests: []string{},
-			},
-		},
-		Descriptor: sbom.Descriptor{
-			Name:    "syft",
-			Version: "v0.42.0-bogus",
-			// the application configuration should be persisted here, however, we do not want to import
-			// the application configuration in this package (it's reserved only for ingestion by the cmd package)
-			Configuration: map[string]string{
-				"config-key": "config-value",
-			},
-		},
-	}
-
-	testutils.AssertPresenterAgainstGoldenSnapshot(t,
-		Format().Presenter(s),
-		*updateJson,
-	)
-}
@@ -1,12 +0,0 @@
-package syftjson
-
-import "github.com/anchore/syft/syft/format"
-
-func Format() format.Format {
-	return format.NewFormat(
-		format.JSONOption,
-		encoder,
-		decoder,
-		validator,
-	)
-}
@@ -1,8 +0,0 @@
-package model
-
-// Distro provides information about a detected Linux Distro.
-type Distro struct {
-	Name    string `json:"name"`    // Name of the Linux distribution
-	Version string `json:"version"` // Version of the Linux distribution (major or major.minor version)
-	IDLike  string `json:"idLike"`  // the ID_LIKE field found within the /etc/os-release file
-}
@@ -1,25 +0,0 @@
-package model
-
-// Document represents the syft cataloging findings as a JSON document
-type Document struct {
-	Artifacts             []Package      `json:"artifacts"` // Artifacts is the list of packages discovered and placed into the catalog
-	ArtifactRelationships []Relationship `json:"artifactRelationships"`
-	Files                 []File         `json:"files,omitempty"`   // note: must have omitempty
-	Secrets               []Secrets      `json:"secrets,omitempty"` // note: must have omitempty
-	Source                Source         `json:"source"`            // Source represents the original object that was cataloged
-	Distro                Distro         `json:"distro"`            // Distro represents the Linux distribution that was detected from the source
-	Descriptor            Descriptor     `json:"descriptor"`        // Descriptor is a block containing self-describing information about syft
-	Schema                Schema         `json:"schema"`            // Schema is a block reserved for defining the version for the shape of this JSON document and where to find the schema document to validate the shape
-}
-
-// Descriptor describes what created the document as well as surrounding metadata
-type Descriptor struct {
-	Name          string      `json:"name"`
-	Version       string      `json:"version"`
-	Configuration interface{} `json:"configuration,omitempty"`
-}
-
-type Schema struct {
-	Version string `json:"version"`
-	URL     string `json:"url"`
-}
@@ -1,25 +0,0 @@
-package model
-
-import (
-	"github.com/anchore/syft/syft/file"
-
-	"github.com/anchore/syft/syft/source"
-)
-
-type File struct {
-	ID              string                `json:"id"`
-	Location        source.Coordinates    `json:"location"`
-	Metadata        *FileMetadataEntry    `json:"metadata,omitempty"`
-	Contents        string                `json:"contents,omitempty"`
-	Digests         []file.Digest         `json:"digests,omitempty"`
-	Classifications []file.Classification `json:"classifications,omitempty"`
-}
-
-type FileMetadataEntry struct {
-	Mode            int             `json:"mode"`
-	Type            source.FileType `json:"type"`
-	LinkDestination string          `json:"linkDestination,omitempty"`
-	UserID          int             `json:"userID"`
-	GroupID         int             `json:"groupID"`
-	MIMEType        string          `json:"mimeType"`
-}
@@ -1,123 +0,0 @@
-package model
-
-import (
-	"encoding/json"
-	"fmt"
-
-	"github.com/anchore/syft/internal/log"
-	"github.com/anchore/syft/syft/pkg"
-	"github.com/anchore/syft/syft/source"
-)
-
-// Package represents a pkg.Package object specialized for JSON marshaling and unmarshalling.
-type Package struct {
-	PackageBasicData
-	PackageCustomData
-}
-
-// PackageBasicData contains non-ambiguous values (type-wise) from pkg.Package.
-type PackageBasicData struct {
-	ID        string               `json:"id"`
-	Name      string               `json:"name"`
-	Version   string               `json:"version"`
-	Type      pkg.Type             `json:"type"`
-	FoundBy   string               `json:"foundBy"`
-	Locations []source.Coordinates `json:"locations"`
-	Licenses  []string             `json:"licenses"`
-	Language  pkg.Language         `json:"language"`
-	CPEs      []string             `json:"cpes"`
-	PURL      string               `json:"purl"`
-}
-
-// PackageCustomData contains ambiguous values (type-wise) from pkg.Package.
-type PackageCustomData struct {
-	MetadataType pkg.MetadataType `json:"metadataType"`
-	Metadata     interface{}      `json:"metadata"`
-}
-
-// packageMetadataUnpacker is all values needed from Package to disambiguate ambiguous fields during json unmarshaling.
-type packageMetadataUnpacker struct {
-	MetadataType pkg.MetadataType `json:"metadataType"`
-	Metadata     json.RawMessage  `json:"metadata"`
-}
-
-func (p *packageMetadataUnpacker) String() string {
-	return fmt.Sprintf("metadataType: %s, metadata: %s", p.MetadataType, string(p.Metadata))
-}
-
-// UnmarshalJSON is a custom unmarshaller for handling basic values and values with ambiguous types.
-// nolint:funlen
-func (p *Package) UnmarshalJSON(b []byte) error {
-	var basic PackageBasicData
-	if err := json.Unmarshal(b, &basic); err != nil {
-		return err
-	}
-	p.PackageBasicData = basic
-
-	var unpacker packageMetadataUnpacker
-	if err := json.Unmarshal(b, &unpacker); err != nil {
-		log.Warnf("failed to unmarshall into packageMetadataUnpacker: %v", err)
-		return err
-	}
-
-	p.MetadataType = unpacker.MetadataType
-
-	switch p.MetadataType {
-	case pkg.ApkMetadataType:
-		var payload pkg.ApkMetadata
-		if err := json.Unmarshal(unpacker.Metadata, &payload); err != nil {
-			return err
-		}
-		p.Metadata = payload
-	case pkg.RpmdbMetadataType:
-		var payload pkg.RpmdbMetadata
-		if err := json.Unmarshal(unpacker.Metadata, &payload); err != nil {
-			return err
-		}
-		p.Metadata = payload
-	case pkg.DpkgMetadataType:
-		var payload pkg.DpkgMetadata
-		if err := json.Unmarshal(unpacker.Metadata, &payload); err != nil {
-			return err
-		}
-		p.Metadata = payload
-	case pkg.JavaMetadataType:
-		var payload pkg.JavaMetadata
-		if err := json.Unmarshal(unpacker.Metadata, &payload); err != nil {
-			return err
-		}
-		p.Metadata = payload
-	case pkg.RustCargoPackageMetadataType:
-		var payload pkg.CargoPackageMetadata
-		if err := json.Unmarshal(unpacker.Metadata, &payload); err != nil {
-			return err
-		}
-		p.Metadata = payload
-	case pkg.GemMetadataType:
-		var payload pkg.GemMetadata
-		if err := json.Unmarshal(unpacker.Metadata, &payload); err != nil {
-			return err
-		}
-		p.Metadata = payload
-	case pkg.KbPackageMetadataType:
-		var payload pkg.KbPackageMetadata
-		if err := json.Unmarshal(unpacker.Metadata, &payload); err != nil {
-			return err
-		}
-		p.Metadata = payload
-	case pkg.PythonPackageMetadataType:
-		var payload pkg.PythonPackageMetadata
-		if err := json.Unmarshal(unpacker.Metadata, &payload); err != nil {
-			return err
-		}
-		p.Metadata = payload
-	case pkg.NpmPackageJSONMetadataType:
-		var payload pkg.NpmPackageJSONMetadata
-		if err := json.Unmarshal(unpacker.Metadata, &payload); err != nil {
-			return err
-		}
-		p.Metadata = payload
-	}
-
-	return nil
-}
@@ -1,8 +0,0 @@
-package model
-
-type Relationship struct {
-	Parent   string      `json:"parent"`
-	Child    string      `json:"child"`
-	Type     string      `json:"type"`
-	Metadata interface{} `json:"metadata,omitempty"`
-}
@@ -1,11 +0,0 @@
-package model
-
-import (
-	"github.com/anchore/syft/syft/file"
-	"github.com/anchore/syft/syft/source"
-)
-
-type Secrets struct {
-	Location source.Coordinates  `json:"location"`
-	Secrets  []file.SearchResult `json:"secrets"`
-}
@@ -1,52 +0,0 @@
-package model
-
-import (
-	"encoding/json"
-	"fmt"
-	"strconv"
-
-	"github.com/anchore/syft/syft/source"
-)
-
-// Source object represents the thing that was cataloged
-type Source struct {
-	Type   string      `json:"type"`
-	Target interface{} `json:"target"`
-}
-
-// sourceUnpacker is used to unmarshal Source objects
-type sourceUnpacker struct {
-	Type   string          `json:"type"`
-	Target json.RawMessage `json:"target"`
-}
-
-// UnmarshalJSON populates a source object from JSON bytes.
-func (s *Source) UnmarshalJSON(b []byte) error {
-	var unpacker sourceUnpacker
-	if err := json.Unmarshal(b, &unpacker); err != nil {
-		return err
-	}
-
-	s.Type = unpacker.Type
-
-	switch s.Type {
-	case "directory":
-		if target, err := strconv.Unquote(string(unpacker.Target)); err == nil {
-			s.Target = target
-		} else {
-			s.Target = string(unpacker.Target[:])
-		}
-
-	case "image":
-		var payload source.ImageMetadata
-		if err := json.Unmarshal(unpacker.Target, &payload); err != nil {
-			return err
-		}
-		s.Target = payload
-
-	default:
-		return fmt.Errorf("unsupported package metadata type: %+v", s.Type)
-	}
-
-	return nil
-}
@@ -1,4 +0,0 @@
-# Note: changes to this file will result in updating several test values. Consider making a new image fixture instead of editing this one.
-FROM scratch
-ADD file-1.txt /somefile-1.txt
-ADD file-2.txt /somefile-2.txt
@@ -1 +0,0 @@
-this file has contents
@@ -1 +0,0 @@
-file-2 contents!
@@ -1,221 +0,0 @@
-package syftjson
-
-import (
-	"fmt"
-	"sort"
-	"strconv"
-
-	"github.com/anchore/syft/syft/file"
-
-	"github.com/anchore/syft/syft/artifact"
-
-	"github.com/anchore/syft/syft/sbom"
-
-	"github.com/anchore/syft/internal"
-	"github.com/anchore/syft/internal/formats/syftjson/model"
-	"github.com/anchore/syft/internal/log"
-	"github.com/anchore/syft/syft/distro"
-	"github.com/anchore/syft/syft/pkg"
-	"github.com/anchore/syft/syft/source"
-)
-
-// TODO: this is exported for the use of the power-user command (temp)
-func ToFormatModel(s sbom.SBOM) model.Document {
-	src, err := toSourceModel(s.Source)
-	if err != nil {
-		log.Warnf("unable to create syft-json source object: %+v", err)
-	}
-
-	return model.Document{
-		Artifacts:             toPackageModels(s.Artifacts.PackageCatalog),
-		ArtifactRelationships: toRelationshipModel(s.Relationships),
-		Files:                 toFile(s),
-		Secrets:               toSecrets(s.Artifacts.Secrets),
-		Source:                src,
-		Distro:                toDistroModel(s.Artifacts.Distro),
-		Descriptor:            toDescriptor(s.Descriptor),
-		Schema: model.Schema{
-			Version: internal.JSONSchemaVersion,
-			URL:     fmt.Sprintf("https://raw.githubusercontent.com/anchore/syft/main/schema/json/schema-%s.json", internal.JSONSchemaVersion),
-		},
-	}
-}
-
-func toDescriptor(d sbom.Descriptor) model.Descriptor {
-	return model.Descriptor{
-		Name:          d.Name,
-		Version:       d.Version,
-		Configuration: d.Configuration,
-	}
-}
-
-func toSecrets(data map[source.Coordinates][]file.SearchResult) []model.Secrets {
-	results := make([]model.Secrets, 0)
-	for coordinates, secrets := range data {
-		results = append(results, model.Secrets{
-			Location: coordinates,
-			Secrets:  secrets,
-		})
-	}
-
-	// sort by real path then virtual path to ensure the result is stable across multiple runs
-	sort.SliceStable(results, func(i, j int) bool {
-		return results[i].Location.RealPath < results[j].Location.RealPath
-	})
-	return results
-}
-
-func toFile(s sbom.SBOM) []model.File {
-	results := make([]model.File, 0)
-	artifacts := s.Artifacts
-
-	for _, coordinates := range sbom.AllCoordinates(s) {
-		var metadata *source.FileMetadata
-		if metadataForLocation, exists := artifacts.FileMetadata[coordinates]; exists {
-			metadata = &metadataForLocation
-		}
-
-		var digests []file.Digest
-		if digestsForLocation, exists := artifacts.FileDigests[coordinates]; exists {
-			digests = digestsForLocation
-		}
-
-		var classifications []file.Classification
-		if classificationsForLocation, exists := artifacts.FileClassifications[coordinates]; exists {
-			classifications = classificationsForLocation
-		}
-
-		var contents string
-		if contentsForLocation, exists := artifacts.FileContents[coordinates]; exists {
-			contents = contentsForLocation
-		}
-
-		results = append(results, model.File{
-			ID:              string(coordinates.ID()),
-			Location:        coordinates,
-			Metadata:        toFileMetadataEntry(coordinates, metadata),
-			Digests:         digests,
-			Classifications: classifications,
-			Contents:        contents,
-		})
-	}
-
-	// sort by real path then virtual path to ensure the result is stable across multiple runs
-	sort.SliceStable(results, func(i, j int) bool {
-		return results[i].Location.RealPath < results[j].Location.RealPath
-	})
-	return results
-}
-
-func toFileMetadataEntry(coordinates source.Coordinates, metadata *source.FileMetadata) *model.FileMetadataEntry {
-	if metadata == nil {
-		return nil
-	}
-
-	mode, err := strconv.Atoi(fmt.Sprintf("%o", metadata.Mode))
-	if err != nil {
-		log.Warnf("invalid mode found in file catalog @ location=%+v mode=%q: %+v", coordinates, metadata.Mode, err)
-		mode = 0
-	}
-
-	return &model.FileMetadataEntry{
-		Mode:            mode,
-		Type:            metadata.Type,
-		LinkDestination: metadata.LinkDestination,
-		UserID:          metadata.UserID,
-		GroupID:         metadata.GroupID,
-		MIMEType:        metadata.MIMEType,
-	}
-}
-
-func toPackageModels(catalog *pkg.Catalog) []model.Package {
-	artifacts := make([]model.Package, 0)
-	if catalog == nil {
-		return artifacts
-	}
-	for _, p := range catalog.Sorted() {
-		artifacts = append(artifacts, toPackageModel(p))
-	}
-	return artifacts
-}
-
-// toPackageModel crates a new Package from the given pkg.Package.
-func toPackageModel(p pkg.Package) model.Package {
-	var cpes = make([]string, len(p.CPEs))
-	for i, c := range p.CPEs {
-		cpes[i] = c.BindToFmtString()
-	}
-
-	var licenses = make([]string, 0)
-	if p.Licenses != nil {
-		licenses = p.Licenses
-	}
-
-	var coordinates = make([]source.Coordinates, len(p.Locations))
-	for i, l := range p.Locations {
-		coordinates[i] = l.Coordinates
-	}
-
-	return model.Package{
-		PackageBasicData: model.PackageBasicData{
-			ID:        string(p.ID()),
-			Name:      p.Name,
-			Version:   p.Version,
-			Type:      p.Type,
-			FoundBy:   p.FoundBy,
-			Locations: coordinates,
-			Licenses:  licenses,
-			Language:  p.Language,
-			CPEs:      cpes,
-			PURL:      p.PURL,
-		},
-		PackageCustomData: model.PackageCustomData{
-			MetadataType: p.MetadataType,
-			Metadata:     p.Metadata,
-		},
-	}
-}
-
-func toRelationshipModel(relationships []artifact.Relationship) []model.Relationship {
-	result := make([]model.Relationship, len(relationships))
-	for i, r := range relationships {
-		result[i] = model.Relationship{
-			Parent:   string(r.From.ID()),
-			Child:    string(r.To.ID()),
-			Type:     string(r.Type),
-			Metadata: r.Data,
-		}
-	}
-	return result
-}
-
-// toSourceModel creates a new source object to be represented into JSON.
-func toSourceModel(src source.Metadata) (model.Source, error) {
-	switch src.Scheme {
-	case source.ImageScheme:
-		return model.Source{
-			Type:   "image",
-			Target: src.ImageMetadata,
-		}, nil
-	case source.DirectoryScheme:
-		return model.Source{
-			Type:   "directory",
-			Target: src.Path,
-		}, nil
-	default:
-		return model.Source{}, fmt.Errorf("unsupported source: %q", src.Scheme)
-	}
-}
-
-// toDistroModel creates a struct with the Linux distribution to be represented in JSON.
-func toDistroModel(d *distro.Distro) model.Distro {
-	if d == nil {
-		return model.Distro{}
-	}
-
-	return model.Distro{
-		Name:    d.Name(),
-		Version: d.FullVersion(),
-		IDLike:  d.IDLike,
-	}
-}
@@ -1,90 +0,0 @@
-package syftjson
-
-import (
-	"github.com/anchore/syft/internal/formats/syftjson/model"
-	"github.com/anchore/syft/internal/log"
-	"github.com/anchore/syft/syft/distro"
-	"github.com/anchore/syft/syft/pkg"
-	"github.com/anchore/syft/syft/sbom"
-	"github.com/anchore/syft/syft/source"
-)
-
-func toSyftModel(doc model.Document) (*sbom.SBOM, error) {
-	dist, err := distro.NewDistro(distro.Type(doc.Distro.Name), doc.Distro.Version, doc.Distro.IDLike)
-	if err != nil {
-		return nil, err
-	}
-
-	return &sbom.SBOM{
-		Artifacts: sbom.Artifacts{
-			PackageCatalog: toSyftCatalog(doc.Artifacts),
-			Distro:         &dist,
-		},
-		Source:     *toSyftSourceData(doc.Source),
-		Descriptor: toSyftDescriptor(doc.Descriptor),
-	}, nil
-}
-
-func toSyftDescriptor(d model.Descriptor) sbom.Descriptor {
-	return sbom.Descriptor{
-		Name:          d.Name,
-		Version:       d.Version,
-		Configuration: d.Configuration,
-	}
-}
-
-func toSyftSourceData(s model.Source) *source.Metadata {
-	switch s.Type {
-	case "directory":
-		return &source.Metadata{
-			Scheme: source.DirectoryScheme,
-			Path:   s.Target.(string),
-		}
-	case "image":
-		return &source.Metadata{
-			Scheme:        source.ImageScheme,
-			ImageMetadata: s.Target.(source.ImageMetadata),
-		}
-	}
-	return nil
-}
-
-func toSyftCatalog(pkgs []model.Package) *pkg.Catalog {
-	catalog := pkg.NewCatalog()
-	for _, p := range pkgs {
-		catalog.Add(toSyftPackage(p))
-	}
-	return catalog
-}
-
-func toSyftPackage(p model.Package) pkg.Package {
-	var cpes []pkg.CPE
-	for _, c := range p.CPEs {
-		value, err := pkg.NewCPE(c)
-		if err != nil {
-			log.Warnf("excluding invalid CPE %q: %v", c, err)
-			continue
-		}
-
-		cpes = append(cpes, value)
-	}
-
-	var locations = make([]source.Location, len(p.Locations))
-	for i, c := range p.Locations {
-		locations[i] = source.NewLocationFromCoordinates(c)
-	}
-
-	return pkg.Package{
-		Name:         p.Name,
-		Version:      p.Version,
-		FoundBy:      p.FoundBy,
-		Locations:    locations,
-		Licenses:     p.Licenses,
-		Language:     p.Language,
-		Type:         p.Type,
-		CPEs:         cpes,
-		PURL:         p.PURL,
-		MetadataType: p.MetadataType,
-		Metadata:     p.Metadata,
-	}
-}
@@ -1,31 +0,0 @@
-package syftjson
-
-import (
-	"encoding/json"
-	"fmt"
-	"io"
-	"strings"
-
-	"github.com/anchore/syft/internal/formats/syftjson/model"
-)
-
-func validator(reader io.Reader) error {
-	type Document struct {
-		Schema model.Schema `json:"schema"`
-	}
-
-	dec := json.NewDecoder(reader)
-
-	var doc Document
-	err := dec.Decode(&doc)
-	if err != nil {
-		return fmt.Errorf("unable to decode: %w", err)
-	}
-
-	// note: we accept all schema versions
-	// TODO: add per-schema version parsing
-	if strings.Contains(doc.Schema.URL, "anchore/syft") {
-		return nil
-	}
-	return fmt.Errorf("could not extract syft schema")
-}
@@ -1,12 +0,0 @@
-package table
-
-import "github.com/anchore/syft/syft/format"
-
-func Format() format.Format {
-	return format.NewFormat(
-		format.TableOption,
-		encoder,
-		nil,
-		nil,
-	)
-}
@@ -1,54 +0,0 @@
-package text
-
-import (
-	"fmt"
-	"io"
-	"text/tabwriter"
-
-	"github.com/anchore/syft/syft/sbom"
-
-	"github.com/anchore/syft/syft/source"
-)
-
-func encoder(output io.Writer, s sbom.SBOM) error {
-	// init the tabular writer
-	w := new(tabwriter.Writer)
-	w.Init(output, 0, 8, 0, '\t', tabwriter.AlignRight)
-
-	switch s.Source.Scheme {
-	case source.DirectoryScheme:
-		fmt.Fprintf(w, "[Path: %s]\n", s.Source.Path)
-	case source.ImageScheme:
-		fmt.Fprintln(w, "[Image]")
-
-		for idx, l := range s.Source.ImageMetadata.Layers {
-			fmt.Fprintln(w, " Layer:\t", idx)
-			fmt.Fprintln(w, " Digest:\t", l.Digest)
-			fmt.Fprintln(w, " Size:\t", l.Size)
-			fmt.Fprintln(w, " MediaType:\t", l.MediaType)
-			fmt.Fprintln(w)
-			w.Flush()
-		}
-	default:
-		return fmt.Errorf("unsupported source: %T", s.Source.Scheme)
-	}
-
-	// populate artifacts...
-	rows := 0
-	for _, p := range s.Artifacts.PackageCatalog.Sorted() {
-		fmt.Fprintf(w, "[%s]\n", p.Name)
-		fmt.Fprintln(w, " Version:\t", p.Version)
-		fmt.Fprintln(w, " Type:\t", string(p.Type))
-		fmt.Fprintln(w, " Found by:\t", p.FoundBy)
-		fmt.Fprintln(w)
-		w.Flush()
-		rows++
-	}
-
-	if rows == 0 {
-		fmt.Fprintln(output, "No packages discovered")
-		return nil
-	}
-
-	return nil
-}
@@ -1,12 +0,0 @@
-package text
-
-import "github.com/anchore/syft/syft/format"
-
-func Format() format.Format {
-	return format.NewFormat(
-		format.TextOption,
-		encoder,
-		nil,
-		nil,
-	)
-}
@@ -1,4 +0,0 @@
-# Note: changes to this file will result in updating several test values. Consider making a new image fixture instead of editing this one.
-FROM scratch
-ADD file-1.txt /somefile-1.txt
-ADD file-2.txt /somefile-2.txt
@@ -1 +0,0 @@
-this file has contents
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Alex Goodman	821210006d	make updates due to linter update Signed-off-by: Alex Goodman <alex.goodman@anchore.com>	2021-10-05 22:51:36 -04:00
Alex Goodman	053768c6c6	update golangci + add additional lint rules Signed-off-by: Alex Goodman <alex.goodman@anchore.com>	2021-10-05 22:50:57 -04:00