From 6f7a4fd3e4e7beeb6f989c4b51e4c6b46d7a1784 Mon Sep 17 00:00:00 2001
From: Alex Goodman <alex.goodman@anchore.com>
Date: Fri, 13 Nov 2020 16:30:31 -0500
Subject: [PATCH] move source metadata upstream and fix tests

Signed-off-by: Alex Goodman <alex.goodman@anchore.com>
---
 cmd/cmd.go                                    |   2 +-
 cmd/root.go                                   |   2 +-
 schema/json/schema.json                       |  55 +++++++-----------
 syft/cataloger/deb/cataloger_test.go          |   4 +-
 syft/cataloger/rpmdb/cataloger.go             |   5 +-
 syft/cataloger/rpmdb/parse_rpmdb.go           |   1 +
 syft/cataloger/rpmdb/parse_rpmdb_test.go      |  10 ++--
 syft/lib.go                                   |   6 +-
 syft/pkg/dpkg_metadata.go                     |   2 +-
 syft/pkg/package.go                           |  18 +++---
 syft/presenter/cyclonedx/presenter.go         |  37 +++++-------
 syft/presenter/cyclonedx/presenter_test.go    |   8 +--
 syft/presenter/json/artifact.go               |  20 ++++---
 syft/presenter/json/document.go               |  21 +++----
 syft/presenter/json/image.go                  |  44 --------------
 syft/presenter/json/presenter.go              |  16 ++---
 syft/presenter/json/presenter_test.go         |  10 ++--
 syft/presenter/json/source.go                 |  12 ++--
 .../snapshot/TestJsonDirsPresenter.golden     |  43 ++++++++++++--
 .../snapshot/TestJsonImgsPresenter.golden     |  47 ++++++++++++---
 .../anchore-fixture-image-simple.golden       | Bin 23552 -> 0 bytes
 .../stereoscope-fixture-image-simple.golden   | Bin 22016 -> 23552 bytes
 syft/presenter/presenter.go                   |  10 ++--
 syft/presenter/table/presenter.go             |   5 +-
 syft/presenter/table/presenter_test.go        |   5 +-
 syft/presenter/text/presenter.go              |  28 ++++-----
 syft/presenter/text/presenter_test.go         |   6 +-
 syft/source/image_metadata.go                 |  44 ++++++++++++++
 syft/source/location.go                       |  14 ++---
 syft/source/metadata.go                       |   8 +++
 syft/source/scope.go                          |  24 +++-----
 syft/source/scope_test.go                     |  17 ------
 syft/source/source.go                         |  40 +++++--------
 syft/source/source_test.go                    |  29 ++++-----
 test/integration/document_import_test.go      |   4 +-
 test/integration/json_schema_test.go          |   2 +-
 36 files changed, 305 insertions(+), 294 deletions(-)
 delete mode 100644 syft/presenter/json/image.go
 delete mode 100644 syft/presenter/json/test-fixtures/snapshot/anchore-fixture-image-simple.golden
 create mode 100644 syft/source/image_metadata.go
 create mode 100644 syft/source/metadata.go
 delete mode 100644 syft/source/scope_test.go

diff --git a/cmd/cmd.go b/cmd/cmd.go
index 0c4a36327..70197c968 100644
--- a/cmd/cmd.go
+++ b/cmd/cmd.go
@@ -50,7 +50,7 @@ func setGlobalCliOptions() {
 	flag := "scope"
 	rootCmd.Flags().StringP(
 		"scope", "s", source.SquashedScope.String(),
-		fmt.Sprintf("selection of layers to catalog, options=%v", source.Options))
+		fmt.Sprintf("selection of layers to catalog, options=%v", source.AllScopes))
 	if err := viper.BindPFlag(flag, rootCmd.Flags().Lookup(flag)); err != nil {
 		fmt.Printf("unable to bind flag '%s': %+v", flag, err)
 		os.Exit(1)
diff --git a/cmd/root.go b/cmd/root.go
index ffa936f90..3abccd404 100644
--- a/cmd/root.go
+++ b/cmd/root.go
@@ -100,7 +100,7 @@ func startWorker(userInput string) <-chan error {
 
 		bus.Publish(partybus.Event{
 			Type:  event.CatalogerFinished,
-			Value: presenter.GetPresenter(appConfig.PresenterOpt, *scope, catalog, distro),
+			Value: presenter.GetPresenter(appConfig.PresenterOpt, scope.Metadata, catalog, distro),
 		})
 	}()
 	return errs
diff --git a/schema/json/schema.json b/schema/json/schema.json
index 556fd50e7..01f9e3e10 100644
--- a/schema/json/schema.json
+++ b/schema/json/schema.json
@@ -5,10 +5,7 @@
             "items": {
                 "properties": {
                     "foundBy": {
-                        "items": {
-                            "type": "string"
-                        },
-                        "type": "array"
+                        "type": "string"
                     },
                     "language": {
                         "type": "string"
@@ -27,33 +24,21 @@
                         ]
                     },
                     "locations": {
-                        "anyOf": [
-                            {
-                                "type": "null"
-                            },
-                            {
-                                "items": {
-                                    "properties": {
-                                        "layerID": {
-                                            "type": "string"
-                                        },
-                                        "layerIndex": {
-                                            "type": "integer"
-                                        },
-                                        "path": {
-                                            "type": "string"
-                                        }
-                                    },
-                                    "required": [
-                                        "layerID",
-                                        "layerIndex",
-                                        "path"
-                                    ],
-                                    "type": "object"
+                        "items": {
+                            "properties": {
+                                "layerID": {
+                                    "type": "string"
                                 },
-                                "type": "array"
-                            }
-                        ]
+                                "path": {
+                                    "type": "string"
+                                }
+                            },
+                            "required": [
+                                "path"
+                            ],
+                            "type": "object"
+                        },
+                        "type": "array"
                     },
                     "metadata": {
                         "properties": {
@@ -354,7 +339,7 @@
                 "name": {
                     "type": "string"
                 },
-                "reportTimestamp": {
+                "scope": {
                     "type": "string"
                 },
                 "version": {
@@ -363,7 +348,7 @@
             },
             "required": [
                 "name",
-                "reportTimestamp",
+                "scope",
                 "version"
             ],
             "type": "object"
@@ -432,6 +417,9 @@
                                         "type": "string"
                                     },
                                     "type": "array"
+                                },
+                                "userInput": {
+                                    "type": "string"
                                 }
                             },
                             "required": [
@@ -439,7 +427,8 @@
                                 "layers",
                                 "mediaType",
                                 "size",
-                                "tags"
+                                "tags",
+                                "userInput"
                             ],
                             "type": "object"
                         }
diff --git a/syft/cataloger/deb/cataloger_test.go b/syft/cataloger/deb/cataloger_test.go
index d340316ed..9a3e390c7 100644
--- a/syft/cataloger/deb/cataloger_test.go
+++ b/syft/cataloger/deb/cataloger_test.go
@@ -54,7 +54,7 @@ func TestDpkgCataloger(t *testing.T) {
 			img, cleanup := imagetest.GetFixtureImage(t, "docker-archive", "image-dpkg")
 			defer cleanup()
 
-			s, err := source.NewFromImage(img, source.AllLayersScope)
+			s, err := source.NewFromImage(img, source.AllLayersScope, "")
 			if err != nil {
 				t.Fatal(err)
 			}
@@ -79,7 +79,7 @@ func TestDpkgCataloger(t *testing.T) {
 				// we will test the sources separately
 				var sourcesList = make([]string, len(a.Locations))
 				for i, s := range a.Locations {
-					sourcesList[i] = string(s.Path)
+					sourcesList[i] = s.Path
 				}
 				a.Locations = nil
 
diff --git a/syft/cataloger/rpmdb/cataloger.go b/syft/cataloger/rpmdb/cataloger.go
index 3ec99e112..c9234a1c7 100644
--- a/syft/cataloger/rpmdb/cataloger.go
+++ b/syft/cataloger/rpmdb/cataloger.go
@@ -12,7 +12,8 @@ import (
 )
 
 const (
-	packagesGlob = "**/var/lib/rpm/Packages"
+	packagesGlob  = "**/var/lib/rpm/Packages"
+	catalogerName = "rpmdb-cataloger"
 )
 
 type Cataloger struct{}
@@ -24,7 +25,7 @@ func NewRpmdbCataloger() *Cataloger {
 
 // Name returns a string that uniquely describes a cataloger
 func (c *Cataloger) Name() string {
-	return "rpmdb-cataloger"
+	return catalogerName
 }
 
 // Catalog is given an object to resolve file references and content, this function returns any discovered Packages after analyzing rpm db installation.
diff --git a/syft/cataloger/rpmdb/parse_rpmdb.go b/syft/cataloger/rpmdb/parse_rpmdb.go
index 05b6ec157..fcf251cd0 100644
--- a/syft/cataloger/rpmdb/parse_rpmdb.go
+++ b/syft/cataloger/rpmdb/parse_rpmdb.go
@@ -55,6 +55,7 @@ func parseRpmDB(resolver source.FileResolver, dbLocation source.Location, reader
 			Version: fmt.Sprintf("%s-%s", entry.Version, entry.Release), // this is what engine does
 			//Version: fmt.Sprintf("%d:%s-%s.%s", entry.Epoch, entry.Version, entry.Release, entry.Arch),
 			Locations:    []source.Location{dbLocation},
+			FoundBy:      catalogerName,
 			Type:         pkg.RpmPkg,
 			MetadataType: pkg.RpmdbMetadataType,
 			Metadata: pkg.RpmdbMetadata{
diff --git a/syft/cataloger/rpmdb/parse_rpmdb_test.go b/syft/cataloger/rpmdb/parse_rpmdb_test.go
index 2b89e7dff..a80fa2523 100644
--- a/syft/cataloger/rpmdb/parse_rpmdb_test.go
+++ b/syft/cataloger/rpmdb/parse_rpmdb_test.go
@@ -43,7 +43,7 @@ func (r *rpmdbTestFileResolverMock) RelativeFileByPath(source.Location, string)
 }
 
 func TestParseRpmDB(t *testing.T) {
-	dbRef := file.NewFileReference("test-path")
+	dbLocation := source.NewLocation("test-path")
 
 	tests := []struct {
 		fixture     string
@@ -58,7 +58,8 @@ func TestParseRpmDB(t *testing.T) {
 				"dive": {
 					Name:         "dive",
 					Version:      "0.9.2-1",
-					Source:       []file.Reference{dbRef},
+					Locations:    []source.Location{dbLocation},
+					FoundBy:      catalogerName,
 					Type:         pkg.RpmPkg,
 					MetadataType: pkg.RpmdbMetadataType,
 					Metadata: pkg.RpmdbMetadata{
@@ -84,7 +85,8 @@ func TestParseRpmDB(t *testing.T) {
 				"dive": {
 					Name:         "dive",
 					Version:      "0.9.2-1",
-					Source:       []file.Reference{dbRef},
+					Locations:    []source.Location{dbLocation},
+					FoundBy:      catalogerName,
 					Type:         pkg.RpmPkg,
 					MetadataType: pkg.RpmdbMetadataType,
 					Metadata: pkg.RpmdbMetadata{
@@ -120,7 +122,7 @@ func TestParseRpmDB(t *testing.T) {
 
 			fileResolver := newTestFileResolver(test.ignorePaths)
 
-			actual, err := parseRpmDB(fileResolver, dbRef, fixture)
+			actual, err := parseRpmDB(fileResolver, dbLocation, fixture)
 			if err != nil {
 				t.Fatalf("failed to parse rpmdb: %+v", err)
 			}
diff --git a/syft/lib.go b/syft/lib.go
index 930669371..9a1d81675 100644
--- a/syft/lib.go
+++ b/syft/lib.go
@@ -36,7 +36,7 @@ import (
 // set of packages, the identified Linux distribution, and the source object used to wrap the data source.
 func Catalog(userInput string, scoptOpt source.Scope) (*pkg.Catalog, *source.Source, *distro.Distro, error) {
 	log.Info("cataloging image")
-	s, cleanup, err := source.NewSource(userInput, scoptOpt)
+	s, cleanup, err := source.New(userInput, scoptOpt)
 	defer cleanup()
 	if err != nil {
 		return nil, nil, nil, err
@@ -70,13 +70,13 @@ func CatalogFromScope(s source.Source) (*pkg.Catalog, error) {
 
 	// conditionally have two sets of catalogers
 	var catalogers []cataloger.Cataloger
-	switch s.Scheme {
+	switch s.Metadata.Scheme {
 	case source.ImageScheme:
 		catalogers = cataloger.ImageCatalogers()
 	case source.DirectoryScheme:
 		catalogers = cataloger.DirectoryCatalogers()
 	default:
-		return nil, fmt.Errorf("unable to determine cataloger set from scheme=%+v", s.Scheme)
+		return nil, fmt.Errorf("unable to determine cataloger set from scheme=%+v", s.Metadata.Scheme)
 	}
 
 	return cataloger.Catalog(s.Resolver, catalogers...)
diff --git a/syft/pkg/dpkg_metadata.go b/syft/pkg/dpkg_metadata.go
index a29bf8169..f1e80802e 100644
--- a/syft/pkg/dpkg_metadata.go
+++ b/syft/pkg/dpkg_metadata.go
@@ -9,7 +9,7 @@ import (
 // at http://manpages.ubuntu.com/manpages/xenial/man1/dpkg-query.1.html in the --showformat section.
 type DpkgMetadata struct {
 	Package       string           `mapstructure:"Package" json:"package"`
-	Source        string           `mapstructure:"Locations" json:"source"`
+	Source        string           `mapstructure:"Source" json:"source"`
 	Version       string           `mapstructure:"Version" json:"version"`
 	Architecture  string           `mapstructure:"Architecture" json:"architecture"`
 	Maintainer    string           `mapstructure:"Maintainer" json:"maintainer"`
diff --git a/syft/pkg/package.go b/syft/pkg/package.go
index 525e5e893..7e97ee8a8 100644
--- a/syft/pkg/package.go
+++ b/syft/pkg/package.go
@@ -19,16 +19,16 @@ type ID int64
 // Package represents an application or library that has been bundled into a distributable format.
 type Package struct {
 	id        ID                // uniquely identifies a package, set by the cataloger
-	Name      string            `json:"manifest"` // the package name
-	Version   string            `json:"version"`  // the version of the package
-	FoundBy   string            `json:"foundBy"`  // the specific cataloger that discovered this package
-	Locations []source.Location `json:"-"`        // the locations that lead to the discovery of this package (note: this is not necessarily the locations that make up this package)
+	Name      string            // the package name
+	Version   string            // the version of the package
+	FoundBy   string            // the specific cataloger that discovered this package
+	Locations []source.Location // the locations that lead to the discovery of this package (note: this is not necessarily the locations that make up this package)
 	// TODO: should we move licenses into metadata?
-	Licenses     []string     `json:"licenses"`               // licenses discovered with the package metadata
-	Language     Language     `json:"language"`               // the language ecosystem this package belongs to (e.g. JavaScript, Python, etc)
-	Type         Type         `json:"type"`                   // the package type (e.g. Npm, Yarn, Python, Rpm, Deb, etc)
-	MetadataType MetadataType `json:"metadataType,omitempty"` // the shape of the additional data in the "metadata" field
-	Metadata     interface{}  `json:"metadata,omitempty"`     // additional data found while parsing the package source
+	Licenses     []string     // licenses discovered with the package metadata
+	Language     Language     // the language ecosystem this package belongs to (e.g. JavaScript, Python, etc)
+	Type         Type         // the package type (e.g. Npm, Yarn, Python, Rpm, Deb, etc)
+	MetadataType MetadataType // the shape of the additional data in the "metadata" field
+	Metadata     interface{}  // additional data found while parsing the package source
 }
 
 // ID returns the package ID, which is unique relative to a package catalog.
diff --git a/syft/presenter/cyclonedx/presenter.go b/syft/presenter/cyclonedx/presenter.go
index b73052d51..2a28b8db7 100644
--- a/syft/presenter/cyclonedx/presenter.go
+++ b/syft/presenter/cyclonedx/presenter.go
@@ -16,17 +16,17 @@ import (
 
 // Presenter writes a CycloneDX report from the given Catalog and Locations contents
 type Presenter struct {
-	catalog *pkg.Catalog
-	source  source.Source
-	distro  distro.Distro
+	catalog     *pkg.Catalog
+	srcMetadata source.Metadata
+	distro      distro.Distro
 }
 
 // NewPresenter creates a CycloneDX presenter from the given Catalog and Locations objects.
-func NewPresenter(catalog *pkg.Catalog, s source.Source, d distro.Distro) *Presenter {
+func NewPresenter(catalog *pkg.Catalog, s source.Metadata, d distro.Distro) *Presenter {
 	return &Presenter{
-		catalog: catalog,
-		source:  s,
-		distro:  d,
+		catalog:     catalog,
+		srcMetadata: s,
+		distro:      d,
 	}
 }
 
@@ -34,33 +34,26 @@ func NewPresenter(catalog *pkg.Catalog, s source.Source, d distro.Distro) *Prese
 func (pres *Presenter) Present(output io.Writer) error {
 	bom := NewDocumentFromCatalog(pres.catalog, pres.distro)
 
-	switch src := pres.source.Target.(type) {
-	case source.DirSource:
+	switch pres.srcMetadata.Scheme {
+	case source.DirectoryScheme:
 		bom.BomDescriptor.Component = &BdComponent{
 			Component: Component{
 				Type:    "file",
-				Name:    src.Path,
+				Name:    pres.srcMetadata.Path,
 				Version: "",
 			},
 		}
-	case source.ImageSource:
-		var imageID string
-		var versionStr string
-		if len(src.Img.Metadata.Tags) > 0 {
-			imageID = src.Img.Metadata.Tags[0].Context().Name()
-			versionStr = src.Img.Metadata.Tags[0].TagStr()
-		} else {
-			imageID = src.Img.Metadata.Digest
-		}
+	case source.ImageScheme:
+		// TODO: can we use the tags a bit better?
 		bom.BomDescriptor.Component = &BdComponent{
 			Component: Component{
 				Type:    "container",
-				Name:    imageID,
-				Version: versionStr,
+				Name:    pres.srcMetadata.ImageMetadata.UserInput,
+				Version: pres.srcMetadata.ImageMetadata.Digest,
 			},
 		}
 	default:
-		return fmt.Errorf("unsupported source: %T", src)
+		return fmt.Errorf("unsupported source: %T", pres.srcMetadata.Scheme)
 	}
 
 	encoder := xml.NewEncoder(output)
diff --git a/syft/presenter/cyclonedx/presenter_test.go b/syft/presenter/cyclonedx/presenter_test.go
index 90ca5b309..ee29ca62c 100644
--- a/syft/presenter/cyclonedx/presenter_test.go
+++ b/syft/presenter/cyclonedx/presenter_test.go
@@ -66,7 +66,7 @@ func TestCycloneDxDirsPresenter(t *testing.T) {
 		t.Fatal(err)
 	}
 
-	pres := NewPresenter(catalog, s, d)
+	pres := NewPresenter(catalog, s.Metadata, d)
 
 	// run presenter
 	err = pres.Present(&buffer)
@@ -146,7 +146,7 @@ func TestCycloneDxImgsPresenter(t *testing.T) {
 		},
 	})
 
-	s, err := source.NewFromImage(img, source.AllLayersScope)
+	s, err := source.NewFromImage(img, source.AllLayersScope, "user-image-input")
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -156,7 +156,7 @@ func TestCycloneDxImgsPresenter(t *testing.T) {
 		t.Fatal(err)
 	}
 
-	pres := NewPresenter(catalog, s, d)
+	pres := NewPresenter(catalog, s.Metadata, d)
 
 	// run presenter
 	err = pres.Present(&buffer)
@@ -177,7 +177,7 @@ func TestCycloneDxImgsPresenter(t *testing.T) {
 
 	if !bytes.Equal(expected, actual) {
 		dmp := diffmatchpatch.New()
-		diffs := dmp.DiffMain(string(actual), string(expected), true)
+		diffs := dmp.DiffMain(string(expected), string(actual), true)
 		t.Errorf("mismatched output:\n%s", dmp.DiffPrettyText(diffs))
 	}
 }
diff --git a/syft/presenter/json/artifact.go b/syft/presenter/json/artifact.go
index 8a9e586d7..3aeea21ef 100644
--- a/syft/presenter/json/artifact.go
+++ b/syft/presenter/json/artifact.go
@@ -16,11 +16,11 @@ type Artifact struct {
 type ArtifactBasicMetadata struct {
 	Name      string            `json:"name"`
 	Version   string            `json:"version"`
-	Type      string            `json:"type"`
-	FoundBy   []string          `json:"foundBy"`
+	Type      pkg.Type          `json:"type"`
+	FoundBy   string            `json:"foundBy"`
 	Locations []source.Location `json:"locations"`
 	Licenses  []string          `json:"licenses"`
-	Language  string            `json:"language"`
+	Language  pkg.Language      `json:"language"`
 }
 
 type ArtifactCustomMetadata struct {
@@ -33,17 +33,17 @@ type ArtifactMetadataUnpacker struct {
 	Metadata     json.RawMessage `json:"metadata"`
 }
 
-func NewArtifact(p *pkg.Package, s source.Source) (Artifact, error) {
+func NewArtifact(p *pkg.Package) (Artifact, error) {
 
 	return Artifact{
 		ArtifactBasicMetadata: ArtifactBasicMetadata{
 			Name:      p.Name,
 			Version:   p.Version,
-			Type:      string(p.Type),
-			FoundBy:   []string{p.FoundBy},
+			Type:      p.Type,
+			FoundBy:   p.FoundBy,
 			Locations: p.Locations,
 			Licenses:  p.Licenses,
-			Language:  string(p.Language),
+			Language:  p.Language,
 		},
 		ArtifactCustomMetadata: ArtifactCustomMetadata{
 			MetadataType: p.MetadataType,
@@ -57,9 +57,11 @@ func (a Artifact) ToPackage() pkg.Package {
 		// does not include found-by and locations
 		Name:         a.Name,
 		Version:      a.Version,
+		FoundBy:      a.FoundBy,
 		Licenses:     a.Licenses,
-		Language:     pkg.Language(a.Language),
-		Type:         pkg.Type(a.Type),
+		Language:     a.Language,
+		Locations:    a.Locations,
+		Type:         a.Type,
 		MetadataType: a.MetadataType,
 		Metadata:     a.Metadata,
 	}
diff --git a/syft/presenter/json/document.go b/syft/presenter/json/document.go
index 78cb55ce2..2c20a1a38 100644
--- a/syft/presenter/json/document.go
+++ b/syft/presenter/json/document.go
@@ -1,8 +1,6 @@
 package json
 
 import (
-	"time"
-
 	"github.com/anchore/syft/internal"
 	"github.com/anchore/syft/internal/version"
 	"github.com/anchore/syft/syft/distro"
@@ -19,10 +17,9 @@ type Document struct {
 
 // Descriptor describes what created the document as well as surrounding metadata
 type Descriptor struct {
-	Name            string `json:"name"`
-	Version         string `json:"version"`
-	ReportTimestamp string `json:"reportTimestamp"`
-	// TODO: we should include source option here as well (or in source)
+	Name    string `json:"name"`
+	Version string `json:"version"`
+	Scope   string `json:"scope"`
 }
 
 // Distribution provides information about a detected Linux Distribution
@@ -32,8 +29,8 @@ type Distribution struct {
 	IDLike  string `json:"idLike"`
 }
 
-func NewDocument(catalog *pkg.Catalog, s source.Source, d distro.Distro) (Document, error) {
-	src, err := NewSource(s)
+func NewDocument(catalog *pkg.Catalog, srcMetadata source.Metadata, d distro.Distro) (Document, error) {
+	src, err := NewSource(srcMetadata)
 	if err != nil {
 		return Document{}, nil
 	}
@@ -52,14 +49,14 @@ func NewDocument(catalog *pkg.Catalog, s source.Source, d distro.Distro) (Docume
 			IDLike:  d.IDLike,
 		},
 		Descriptor: Descriptor{
-			Name:            internal.ApplicationName,
-			Version:         version.FromBuild().Version,
-			ReportTimestamp: time.Now().Format(time.RFC3339),
+			Name:    internal.ApplicationName,
+			Version: version.FromBuild().Version,
+			Scope:   srcMetadata.Scope.String(),
 		},
 	}
 
 	for _, p := range catalog.Sorted() {
-		art, err := NewArtifact(p, s)
+		art, err := NewArtifact(p)
 		if err != nil {
 			return Document{}, err
 		}
diff --git a/syft/presenter/json/image.go b/syft/presenter/json/image.go
deleted file mode 100644
index ee7796421..000000000
--- a/syft/presenter/json/image.go
+++ /dev/null
@@ -1,44 +0,0 @@
-package json
-
-import (
-	"github.com/anchore/syft/syft/source"
-)
-
-type Image struct {
-	Layers    []Layer  `json:"layers"`
-	Size      int64    `json:"size"`
-	Digest    string   `json:"digest"`
-	MediaType string   `json:"mediaType"`
-	Tags      []string `json:"tags"`
-}
-
-type Layer struct {
-	MediaType string `json:"mediaType"`
-	Digest    string `json:"digest"`
-	Size      int64  `json:"size"`
-}
-
-func NewImage(src source.ImageSource) *Image {
-	// populate artifacts...
-	tags := make([]string, len(src.Img.Metadata.Tags))
-	for idx, tag := range src.Img.Metadata.Tags {
-		tags[idx] = tag.String()
-	}
-	img := Image{
-		Digest:    src.Img.Metadata.Digest,
-		Size:      src.Img.Metadata.Size,
-		MediaType: string(src.Img.Metadata.MediaType),
-		Tags:      tags,
-		Layers:    make([]Layer, len(src.Img.Layers)),
-	}
-
-	// populate image metadata
-	for idx, l := range src.Img.Layers {
-		img.Layers[idx] = Layer{
-			MediaType: string(l.Metadata.MediaType),
-			Digest:    l.Metadata.Digest,
-			Size:      l.Metadata.Size,
-		}
-	}
-	return &img
-}
diff --git a/syft/presenter/json/presenter.go b/syft/presenter/json/presenter.go
index beb2e689b..00af4ef4e 100644
--- a/syft/presenter/json/presenter.go
+++ b/syft/presenter/json/presenter.go
@@ -10,21 +10,21 @@ import (
 )
 
 type Presenter struct {
-	catalog *pkg.Catalog
-	source  source.Source
-	distro  distro.Distro
+	catalog     *pkg.Catalog
+	srcMetadata source.Metadata
+	distro      distro.Distro
 }
 
-func NewPresenter(catalog *pkg.Catalog, s source.Source, d distro.Distro) *Presenter {
+func NewPresenter(catalog *pkg.Catalog, s source.Metadata, d distro.Distro) *Presenter {
 	return &Presenter{
-		catalog: catalog,
-		source:  s,
-		distro:  d,
+		catalog:     catalog,
+		srcMetadata: s,
+		distro:      d,
 	}
 }
 
 func (pres *Presenter) Present(output io.Writer) error {
-	doc, err := NewDocument(pres.catalog, pres.source, pres.distro)
+	doc, err := NewDocument(pres.catalog, pres.srcMetadata, pres.distro)
 	if err != nil {
 		return err
 	}
diff --git a/syft/presenter/json/presenter_test.go b/syft/presenter/json/presenter_test.go
index 94d052dae..57869e08e 100644
--- a/syft/presenter/json/presenter_test.go
+++ b/syft/presenter/json/presenter_test.go
@@ -56,7 +56,7 @@ func TestJsonDirsPresenter(t *testing.T) {
 	if err != nil {
 		t.Fatal(err)
 	}
-	pres := NewPresenter(catalog, s, d)
+	pres := NewPresenter(catalog, s.Metadata, d)
 
 	// run presenter
 	err = pres.Present(&buffer)
@@ -73,7 +73,7 @@ func TestJsonDirsPresenter(t *testing.T) {
 
 	if !bytes.Equal(expected, actual) {
 		dmp := diffmatchpatch.New()
-		diffs := dmp.DiffMain(string(actual), string(expected), true)
+		diffs := dmp.DiffMain(string(expected), string(actual), true)
 		t.Errorf("mismatched output:\n%s", dmp.DiffPrettyText(diffs))
 	}
 
@@ -123,9 +123,9 @@ func TestJsonImgsPresenter(t *testing.T) {
 		},
 	})
 
-	s, err := source.NewFromImage(img, source.AllLayersScope)
+	s, err := source.NewFromImage(img, source.AllLayersScope, "user-image-input")
 	d := distro.NewUnknownDistro()
-	pres := NewPresenter(catalog, s, d)
+	pres := NewPresenter(catalog, s.Metadata, d)
 
 	// run presenter
 	err = pres.Present(&buffer)
@@ -142,7 +142,7 @@ func TestJsonImgsPresenter(t *testing.T) {
 
 	if !bytes.Equal(expected, actual) {
 		dmp := diffmatchpatch.New()
-		diffs := dmp.DiffMain(string(actual), string(expected), true)
+		diffs := dmp.DiffMain(string(expected), string(actual), true)
 		t.Errorf("mismatched output:\n%s", dmp.DiffPrettyText(diffs))
 	}
 }
diff --git a/syft/presenter/json/source.go b/syft/presenter/json/source.go
index 6172f9bb4..14561a24f 100644
--- a/syft/presenter/json/source.go
+++ b/syft/presenter/json/source.go
@@ -17,14 +17,14 @@ type SourceUnpacker struct {
 	Target json.RawMessage `json:"target"`
 }
 
-func NewSource(s source.Source) (Source, error) {
-	switch src := s.Target.(type) {
-	case source.ImageSource:
+func NewSource(src source.Metadata) (Source, error) {
+	switch src.Scheme {
+	case source.ImageScheme:
 		return Source{
 			Type:   "image",
-			Target: NewImage(src),
+			Target: src.ImageMetadata,
 		}, nil
-	case source.DirSource:
+	case source.DirectoryScheme:
 		return Source{
 			Type:   "directory",
 			Target: src.Path,
@@ -44,7 +44,7 @@ func (s *Source) UnmarshalJSON(b []byte) error {
 
 	switch s.Type {
 	case "image":
-		var payload Image
+		var payload source.ImageMetadata
 		if err := json.Unmarshal(unpacker.Target, &payload); err != nil {
 			return err
 		}
diff --git a/syft/presenter/json/test-fixtures/snapshot/TestJsonDirsPresenter.golden b/syft/presenter/json/test-fixtures/snapshot/TestJsonDirsPresenter.golden
index 2193e7875..7324c5349 100644
--- a/syft/presenter/json/test-fixtures/snapshot/TestJsonDirsPresenter.golden
+++ b/syft/presenter/json/test-fixtures/snapshot/TestJsonDirsPresenter.golden
@@ -3,14 +3,29 @@
   {
    "name": "package-1",
    "version": "1.0.1",
-   "type": "deb",
+   "type": "python",
    "foundBy": [
     "the-cataloger-1"
    ],
    "locations": [
-    "/some/path/pkg1"
+    {
+     "path": "/some/path/pkg1"
+    }
    ],
-   "licenses": null
+   "licenses": [
+    "MIT"
+   ],
+   "language": "python",
+   "metadataType": "python-package-metadata",
+   "metadata": {
+    "name": "package-1",
+    "version": "1.0.1",
+    "license": "",
+    "author": "",
+    "authorEmail": "",
+    "platform": "",
+    "sitePackagesRootPath": ""
+   }
   },
   {
    "name": "package-2",
@@ -20,9 +35,22 @@
     "the-cataloger-2"
    ],
    "locations": [
-    "/some/path/pkg1"
+    {
+     "path": "/some/path/pkg1"
+    }
    ],
-   "licenses": null
+   "licenses": null,
+   "language": "",
+   "metadataType": "dpkg-metadata",
+   "metadata": {
+    "package": "package-2",
+    "source": "",
+    "version": "2.0.1",
+    "architecture": "",
+    "maintainer": "",
+    "installedSize": 0,
+    "files": null
+   }
   }
  ],
  "source": {
@@ -33,5 +61,10 @@
   "name": "",
   "version": "",
   "idLike": ""
+ },
+ "descriptor": {
+  "name": "syft",
+  "version": "[not provided]",
+  "scope": ""
  }
 }
diff --git a/syft/presenter/json/test-fixtures/snapshot/TestJsonImgsPresenter.golden b/syft/presenter/json/test-fixtures/snapshot/TestJsonImgsPresenter.golden
index f3c7f56a2..91b28d91e 100644
--- a/syft/presenter/json/test-fixtures/snapshot/TestJsonImgsPresenter.golden
+++ b/syft/presenter/json/test-fixtures/snapshot/TestJsonImgsPresenter.golden
@@ -3,17 +3,30 @@
   {
    "name": "package-1",
    "version": "1.0.1",
-   "type": "deb",
+   "type": "python",
    "foundBy": [
     "the-cataloger-1"
    ],
    "locations": [
     {
      "path": "/somefile-1.txt",
-     "layerIndex": 0
+     "layerID": "sha256:e158b57d6f5a96ef5fd22f2fe76c70b5ba6ff5b2619f9d83125b2aad0492ac7b"
     }
    ],
-   "licenses": null
+   "licenses": [
+    "MIT"
+   ],
+   "language": "python",
+   "metadataType": "python-package-metadata",
+   "metadata": {
+    "name": "package-1",
+    "version": "1.0.1",
+    "license": "",
+    "author": "",
+    "authorEmail": "",
+    "platform": "",
+    "sitePackagesRootPath": ""
+   }
   },
   {
    "name": "package-2",
@@ -25,10 +38,21 @@
    "locations": [
     {
      "path": "/somefile-2.txt",
-     "layerIndex": 1
+     "layerID": "sha256:da21056e7bf4308ecea0c0836848a7fe92f38fdcf35bc09ee6d98e7ab7beeebf"
     }
    ],
-   "licenses": null
+   "licenses": null,
+   "language": "",
+   "metadataType": "dpkg-metadata",
+   "metadata": {
+    "package": "package-2",
+    "source": "",
+    "version": "2.0.1",
+    "architecture": "",
+    "maintainer": "",
+    "installedSize": 0,
+    "files": null
+   }
   }
  ],
  "source": {
@@ -37,22 +61,22 @@
    "layers": [
     {
      "mediaType": "application/vnd.docker.image.rootfs.diff.tar.gzip",
-     "digest": "sha256:78783bfc74fef84f899b4977561ad1172f87753f82cc2157b06bf097e56dfbce",
+     "digest": "sha256:e158b57d6f5a96ef5fd22f2fe76c70b5ba6ff5b2619f9d83125b2aad0492ac7b",
      "size": 22
     },
     {
      "mediaType": "application/vnd.docker.image.rootfs.diff.tar.gzip",
-     "digest": "sha256:54ec7f643dafbf9f27032a5e60afe06248c0e99b50aed54bb0fe28ea4825ccaf",
+     "digest": "sha256:da21056e7bf4308ecea0c0836848a7fe92f38fdcf35bc09ee6d98e7ab7beeebf",
      "size": 16
     },
     {
      "mediaType": "application/vnd.docker.image.rootfs.diff.tar.gzip",
-     "digest": "sha256:ec4775a139c45b1ddf9ea8e1cb43385e92e5c0bf6ec2e3f4192372785b18c106",
+     "digest": "sha256:f0e18aa6032c24659a9c741fc36ca56f589782ea132061ccf6f52b952403da94",
      "size": 27
     }
    ],
    "size": 65,
-   "digest": "sha256:fedd7bcc0b90f071501b662d8e7c9ac7548b88daba6b3deedfdf33f22ed8d95b",
+   "digest": "sha256:2731251dc34951c0e50fcc643b4c5f74922dad1a5d98f302b504cf46cd5d9368",
    "mediaType": "application/vnd.docker.distribution.manifest.v2+json",
    "tags": [
     "stereoscope-fixture-image-simple:04e16e44161c8888a1a963720fd0443cbf7eef8101434c431de8725cd98cc9f7"
@@ -63,5 +87,10 @@
   "name": "",
   "version": "",
   "idLike": ""
+ },
+ "descriptor": {
+  "name": "syft",
+  "version": "[not provided]",
+  "scope": "AllLayers"
  }
 }
diff --git a/syft/presenter/json/test-fixtures/snapshot/anchore-fixture-image-simple.golden b/syft/presenter/json/test-fixtures/snapshot/anchore-fixture-image-simple.golden
deleted file mode 100644
index 3e1d2daaaed20003cb49b3a526de3f0e8cc9713f..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 23552
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
I{$COJAK@Xtvj6}9

diff --git a/syft/presenter/json/test-fixtures/snapshot/stereoscope-fixture-image-simple.golden b/syft/presenter/json/test-fixtures/snapshot/stereoscope-fixture-image-simple.golden
index c98a9207cba82e4500322a8abc3c47c933deb265..4e7ce36e08086a679c8a074bf4229f4cafee09bc 100644
GIT binary patch
literal 23552
zcmeHPTW{M&7WQ+0h04Bk0ZTq}pAoPR*(N{>6q`lsw!j8KFxQx^Ou8i9#xVTf_fV28
z+lehDlmurpf^3nT3y0r1hdft;wuT$w!Ey~+3UD$g8--RfX-gOgor1?r8KewcYMr<Y
zUNHrXK{Q7P>puV-ln@87_}u^Pj~)=F7?q51!VZ8a1@vGf)=xdW$9db?2A4E+ru!E+
zbiO@}hoSWU^~Fy=|M2qPk1ZDnfaLr>-LLl%Id+%+6cmSp(O{Z9wy5j2FP#2lvKN%E
z(ayh541vM&|9e|kYp!XX{3|Bz%fG}Ma+d!!xNf8QvM56_Erzl|aaf$$CRQEJ<pLpz
zgczw4QVQ#VC*nDCRy(jNS_8^}7TQ^xn5UW(t0+eWgi+y)#kqVFZ5R865u;!X1i!}s
z)A{$meTTa0Y+1$T4Q{3KZ85zpzOUP^vZoP8VUOqaDRx-x|I)^0(ekY8tUvj=3uRSI
zlbyBku(&x^pW`LmKNuSvx;%K?UEFNHJd4%cdFFdBE02p<_J2|RRZOe%+3c|R?i8<R
zvH8QPeY;%ful4NwG`80*ztznjW%c%Xxm@jws%tLJ>avG+G4^Hkuk&(tGu4mQ#o2QB
z)nQTNW-%+P^LNG71`INk@JBOy5t~V`Lp}IeBmew8{f`nsM3(;t0o`IlTc5^M&f=I(
zx_8|cC%!e+8u|m!h5k>dl7dRq|A`Vj)BhHPJKJ2)e$?Mj@$TJzy|WYLi8BHjfs8;#
z;7K7s6(dxT;2C-WiH9g4c`s30=Uybm4W+>bVnr}IF+i0bxJMVD4|s%0JsEEQq0f)J
zXa5P6pa1({l*__4{-o@p@6MavBC)4I@`Z)<^zEuw#ebe1fB(;;^R_vf)!xpIT31%n
zTl+V=tA_cZ#V&3ZuRmy*wI`MeIdv4pf<sbhq(<7yfj1x(1dV=E&76}`DbAu$LfI6Z
zVh{)yiBoMs`5wqE+jpOt<-1J^y(*57U`Oo<qB{2Y@0)L{`s^R0XV0IHLfK5cVaiKu
z1!#0JM5+ZChmL1UXwpG?sRHBCNRyCqgrkSTuxN=2N*X|djmm0tH0l}R+B|={TyWzc
zp=dpg!Hg+8CS)q;l(Pw;TuP~XM@gvtALu3dD>iLeqrU?kDii2?VB1OAc6Ed9j8~Vp
zJTC7~NGBTknov3Sye!WA#^JbYdW^<?bc+_fO)<5e;gf^1AV}0e63}EQCzQp&z!->*
zB}mZ|XJX(997s=j)Y=)(q!Dvs+*qfiw@ydJ)#1988jN8XZ9ZnDAu*>oPl8+Hh;#;h
zP`D(BEE*k*x72ZygjFh-WKr&Wb_vSaB(&BP?yhuhN3UP$9U?8=U5{b9MgG1*2EXMc
zIxL#H?h?9<E{pEstbYc~eL8K=J!ML7%7AUJilr<>f{r_(f<#1&j7g+GX`(4A=@mHP
ztV~HbDv3!Z=w7>U)Y<^3N?5NP&bpilxr2a^QMtq!=;)&b4;qyUuB}SZ(8T7!M<$#H
z6Qe{OBr5Bai!r*inkhjf+FA*WA`c-0SmPBZ2^q;-fh*NUX^NuGC`jUc!b8*<K{>F1
z@z3J*)h52OeLRo%eGUzj_YX7SNWl23LHsB~@2$dMaFjCgKy>h0Aw7dfe4}NA7)>oW
zO{|GKivLQ6{{I~R-90x9rvGl@zxepd`v2~!e{hiFzxzP>>7HY-{13PPDP{b={Vyoy
z|Li3*;S10ISjK;cvH|L1H}T)0Aw`^P75{zT8o8@Ee_nCmYz^<kC-Rt)`&r}%Y?CkU
zCKx<f55@y-$6JQ!muiyjRaqE%<KII5hx$PN2j^M;-wPk0H*Yq(*u;we^yO@t|Gmop
z0MX}vWc&ZqG2e9LlKzvwPbTxf`s~k5hi=@jPmN!f|KImnelY)s@|^#(F}#C1F6m#z
z7V|B4bQ}11`KQ3}{-5Q45NS6We3$<7Y%sR%Ou)7Ie{50zvAX{=$#eXFBl->PWUIP6
ziOr~|{MTRoU3MoUOdgKyWHK2#bsnD)$OvQvG6GK+fuY4Zo2ZPN>VG%&zv%SkSpSjr
zzuhy=VEXSQ{)=_zEXRL#PyHPK-3P```5c4ge|Y>CB)y;iO$e3*=lJg)7-t#(9m)oG
zVz#+vcegdW+hmKOgx^B^=L7Y>n5LQQ|F=oz2j{w*Vf|pYK@DsDe^~R|zyD|D|07D0
zeE%N=`i6r$ECQH2|3)Xay(t6UaB%LH5y%K+1Tq4jEdr;uDia2OH>u<O)QepA{KtCA
zTknFyZG8U+$@#yZ3in5i!_vR+mTyohwo(g@mf%nEtUk7H7gb|jY+~K|`Yeu9`K~WA
z9+&;gkH&3zdWLm^z$3vjBTld|3(M*7os(Er#uSBwC1ad<msE^N6Cj*%e2WymSPH9=
zgvVMi?@dyDx#o}kJBa3|+nzat*D*Aad1V{nWZO%$!)mqHUwssjAL-m6t=baHK+D)Z
z(rr-FI{BxocZ2pRK)w7+ndN^F=9><_EHLrsQ3>tqLI(@!bTI!HS65qO`c1*f{W1a>
LfsDZaF#`VsZMnln

literal 22016
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

diff --git a/syft/presenter/presenter.go b/syft/presenter/presenter.go
index 56f00f9e6..4f1b86224 100644
--- a/syft/presenter/presenter.go
+++ b/syft/presenter/presenter.go
@@ -25,16 +25,16 @@ type Presenter interface {
 }
 
 // GetPresenter returns a presenter for images or directories
-func GetPresenter(option Option, s source.Source, catalog *pkg.Catalog, d *distro.Distro) Presenter {
+func GetPresenter(option Option, srcMetadata source.Metadata, catalog *pkg.Catalog, d *distro.Distro) Presenter {
 	switch option {
 	case JSONPresenter:
-		return json.NewPresenter(catalog, s, *d)
+		return json.NewPresenter(catalog, srcMetadata, *d)
 	case TextPresenter:
-		return text.NewPresenter(catalog, s)
+		return text.NewPresenter(catalog, srcMetadata)
 	case TablePresenter:
-		return table.NewPresenter(catalog, s)
+		return table.NewPresenter(catalog)
 	case CycloneDxPresenter:
-		return cyclonedx.NewPresenter(catalog, s, *d)
+		return cyclonedx.NewPresenter(catalog, srcMetadata, *d)
 	default:
 		return nil
 	}
diff --git a/syft/presenter/table/presenter.go b/syft/presenter/table/presenter.go
index 6af222559..c7303e8a5 100644
--- a/syft/presenter/table/presenter.go
+++ b/syft/presenter/table/presenter.go
@@ -9,18 +9,15 @@ import (
 	"github.com/olekukonko/tablewriter"
 
 	"github.com/anchore/syft/syft/pkg"
-	"github.com/anchore/syft/syft/source"
 )
 
 type Presenter struct {
 	catalog *pkg.Catalog
-	source  source.Source
 }
 
-func NewPresenter(catalog *pkg.Catalog, s source.Source) *Presenter {
+func NewPresenter(catalog *pkg.Catalog) *Presenter {
 	return &Presenter{
 		catalog: catalog,
-		source:  s,
 	}
 }
 
diff --git a/syft/presenter/table/presenter_test.go b/syft/presenter/table/presenter_test.go
index 160e95169..02dd2f5d4 100644
--- a/syft/presenter/table/presenter_test.go
+++ b/syft/presenter/table/presenter_test.go
@@ -43,11 +43,10 @@ func TestTablePresenter(t *testing.T) {
 		Type: pkg.DebPkg,
 	})
 
-	s, err := source.NewFromImage(img, source.AllLayersScope)
-	pres := NewPresenter(catalog, s)
+	pres := NewPresenter(catalog)
 
 	// run presenter
-	err = pres.Present(&buffer)
+	err := pres.Present(&buffer)
 	if err != nil {
 		t.Fatal(err)
 	}
diff --git a/syft/presenter/text/presenter.go b/syft/presenter/text/presenter.go
index aeaf26d67..57764eb8b 100644
--- a/syft/presenter/text/presenter.go
+++ b/syft/presenter/text/presenter.go
@@ -11,14 +11,14 @@ import (
 )
 
 type Presenter struct {
-	catalog *pkg.Catalog
-	source  source.Source
+	catalog     *pkg.Catalog
+	srcMetadata source.Metadata
 }
 
-func NewPresenter(catalog *pkg.Catalog, s source.Source) *Presenter {
+func NewPresenter(catalog *pkg.Catalog, srcMetadata source.Metadata) *Presenter {
 	return &Presenter{
-		catalog: catalog,
-		source:  s,
+		catalog:     catalog,
+		srcMetadata: srcMetadata,
 	}
 }
 
@@ -28,22 +28,22 @@ func (pres *Presenter) Present(output io.Writer) error {
 	w := new(tabwriter.Writer)
 	w.Init(output, 0, 8, 0, '\t', tabwriter.AlignRight)
 
-	switch src := pres.source.Target.(type) {
-	case source.DirSource:
-		fmt.Fprintln(w, fmt.Sprintf("[Path: %s]", src.Path))
-	case source.ImageSource:
+	switch pres.srcMetadata.Scheme {
+	case source.DirectoryScheme:
+		fmt.Fprintln(w, fmt.Sprintf("[Path: %s]", pres.srcMetadata.Path))
+	case source.ImageScheme:
 		fmt.Fprintln(w, "[Image]")
 
-		for idx, l := range src.Img.Layers {
+		for idx, l := range pres.srcMetadata.ImageMetadata.Layers {
 			fmt.Fprintln(w, " Layer:\t", idx)
-			fmt.Fprintln(w, " Digest:\t", l.Metadata.Digest)
-			fmt.Fprintln(w, " Size:\t", l.Metadata.Size)
-			fmt.Fprintln(w, " MediaType:\t", l.Metadata.MediaType)
+			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", src)
+		return fmt.Errorf("unsupported source: %T", pres.srcMetadata.Scheme)
 	}
 
 	// populate artifacts...
diff --git a/syft/presenter/text/presenter_test.go b/syft/presenter/text/presenter_test.go
index 9144977de..4ca2f756b 100644
--- a/syft/presenter/text/presenter_test.go
+++ b/syft/presenter/text/presenter_test.go
@@ -35,7 +35,7 @@ func TestTextDirPresenter(t *testing.T) {
 	if err != nil {
 		t.Fatalf("unable to create source: %+v", err)
 	}
-	pres := NewPresenter(catalog, s)
+	pres := NewPresenter(catalog, s.Metadata)
 
 	// run presenter
 	err = pres.Present(&buffer)
@@ -97,11 +97,11 @@ func TestTextImgPresenter(t *testing.T) {
 		l.Metadata.Digest = "sha256:ad8ecdc058976c07e7e347cb89fa9ad86a294b5ceaae6d09713fb035f84115abf3c4a2388a4af3aa60f13b94f4c6846930bdf53"
 	}
 
-	s, err := source.NewFromImage(img, source.AllLayersScope)
+	s, err := source.NewFromImage(img, source.AllLayersScope, "user-image-input")
 	if err != nil {
 		t.Fatal(err)
 	}
-	pres := NewPresenter(catalog, s)
+	pres := NewPresenter(catalog, s.Metadata)
 	// run presenter
 	err = pres.Present(&buffer)
 	if err != nil {
diff --git a/syft/source/image_metadata.go b/syft/source/image_metadata.go
new file mode 100644
index 000000000..2a9224d7a
--- /dev/null
+++ b/syft/source/image_metadata.go
@@ -0,0 +1,44 @@
+package source
+
+import "github.com/anchore/stereoscope/pkg/image"
+
+type ImageMetadata struct {
+	UserInput string          `json:"userInput"`
+	Layers    []LayerMetadata `json:"layers"`
+	Size      int64           `json:"size"`
+	Digest    string          `json:"digest"`
+	MediaType string          `json:"mediaType"`
+	Tags      []string        `json:"tags"`
+}
+
+type LayerMetadata struct {
+	MediaType string `json:"mediaType"`
+	Digest    string `json:"digest"`
+	Size      int64  `json:"size"`
+}
+
+func NewImageMetadata(img *image.Image, userInput string) ImageMetadata {
+	// populate artifacts...
+	tags := make([]string, len(img.Metadata.Tags))
+	for idx, tag := range img.Metadata.Tags {
+		tags[idx] = tag.String()
+	}
+	theImg := ImageMetadata{
+		UserInput: userInput,
+		Digest:    img.Metadata.Digest,
+		Size:      img.Metadata.Size,
+		MediaType: string(img.Metadata.MediaType),
+		Tags:      tags,
+		Layers:    make([]LayerMetadata, len(img.Layers)),
+	}
+
+	// populate image metadata
+	for idx, l := range img.Layers {
+		theImg.Layers[idx] = LayerMetadata{
+			MediaType: string(l.Metadata.MediaType),
+			Digest:    l.Metadata.Digest,
+			Size:      l.Metadata.Size,
+		}
+	}
+	return theImg
+}
diff --git a/syft/source/location.go b/syft/source/location.go
index f9287d0ab..1fc1250ae 100644
--- a/syft/source/location.go
+++ b/syft/source/location.go
@@ -8,10 +8,9 @@ import (
 )
 
 type Location struct {
-	Path       string `json:"path"`
-	LayerIndex uint   `json:"layerIndex"`
-	LayerID    string `json:"layerID"`
-	ref        file.Reference
+	Path         string `json:"path"`
+	FileSystemID string `json:"layerID,omitempty"` // TODO: comment
+	ref          file.Reference
 }
 
 func NewLocation(path string) Location {
@@ -31,9 +30,8 @@ func NewLocationFromImage(ref file.Reference, img *image.Image) Location {
 	}
 
 	return Location{
-		Path:       string(ref.Path),
-		LayerIndex: entry.Source.Metadata.Index,
-		LayerID:    entry.Source.Metadata.Digest,
-		ref:        ref,
+		Path:         string(ref.Path),
+		FileSystemID: entry.Source.Metadata.Digest,
+		ref:          ref,
 	}
 }
diff --git a/syft/source/metadata.go b/syft/source/metadata.go
new file mode 100644
index 000000000..188118b7b
--- /dev/null
+++ b/syft/source/metadata.go
@@ -0,0 +1,8 @@
+package source
+
+type Metadata struct {
+	Scope         Scope         // specific perspective to catalog
+	Scheme        Scheme        // the source data scheme type (directory or image)
+	ImageMetadata ImageMetadata // all image info (image only)
+	Path          string        // the root path to be cataloged (directory only)
+}
diff --git a/syft/source/scope.go b/syft/source/scope.go
index 0df5d7f23..92cb0b9b1 100644
--- a/syft/source/scope.go
+++ b/syft/source/scope.go
@@ -2,21 +2,15 @@ package source
 
 import "strings"
 
+type Scope string
+
 const (
-	UnknownScope Scope = iota
-	SquashedScope
-	AllLayersScope
+	UnknownScope   Scope = "UnknownScope"
+	SquashedScope  Scope = "Squashed"
+	AllLayersScope Scope = "AllLayers"
 )
 
-type Scope int
-
-var optionStr = []string{
-	"UnknownScope",
-	"Squashed",
-	"AllLayers",
-}
-
-var Options = []Scope{
+var AllScopes = []Scope{
 	SquashedScope,
 	AllLayersScope,
 }
@@ -32,9 +26,5 @@ func ParseScope(userStr string) Scope {
 }
 
 func (o Scope) String() string {
-	if int(o) >= len(optionStr) || o < 0 {
-		return optionStr[0]
-	}
-
-	return optionStr[o]
+	return string(o)
 }
diff --git a/syft/source/scope_test.go b/syft/source/scope_test.go
deleted file mode 100644
index 0c210e013..000000000
--- a/syft/source/scope_test.go
+++ /dev/null
@@ -1,17 +0,0 @@
-package source
-
-import (
-	"fmt"
-	"testing"
-)
-
-func TestOptionStringerBoundary(t *testing.T) {
-	var _ fmt.Stringer = Scope(0)
-
-	for _, c := range []int{-1, 0, 3} {
-		option := Scope(c)
-		if option.String() != UnknownScope.String() {
-			t.Errorf("expected Scope(%d) to be unknown, found '%+v'", c, option)
-		}
-	}
-}
diff --git a/syft/source/source.go b/syft/source/source.go
index b3e49d22d..91ce1009e 100644
--- a/syft/source/source.go
+++ b/syft/source/source.go
@@ -15,29 +15,18 @@ import (
 	"github.com/anchore/stereoscope/pkg/image"
 )
 
-// ImageSource represents a data source that is a container image
-type ImageSource struct {
-	Img *image.Image // the image object to be cataloged
-}
-
-// DirSource represents a data source that is a filesystem directory tree
-type DirSource struct {
-	Path string // the root path to be cataloged
-}
-
 // Source is an object that captures the data source to be cataloged, configuration, and a specific resolver used
 // in cataloging (based on the data source and configuration)
 type Source struct {
-	Scope    Scope       // specific perspective to catalog
-	Resolver Resolver    // a Resolver object to use in file path/glob resolution and file contents resolution
-	Target   interface{} // the specific source object to be cataloged
-	Scheme   Scheme      // the source data scheme type (directory or image)
+	Resolver Resolver     // a Resolver object to use in file path/glob resolution and file contents resolution
+	Image    *image.Image // the image object to be cataloged (image only)
+	Metadata Metadata
 }
 
 type sourceDetector func(string) (image.Source, string, error)
 
-// NewSource produces a Source based on userInput like dir: or image:tag
-func NewSource(userInput string, o Scope) (Source, func(), error) {
+// New produces a Source based on userInput like dir: or image:tag
+func New(userInput string, o Scope) (Source, func(), error) {
 	fs := afero.NewOsFs()
 	parsedScheme, location, err := detectScheme(fs, image.DetectSource, userInput)
 	if err != nil {
@@ -71,7 +60,7 @@ func NewSource(userInput string, o Scope) (Source, func(), error) {
 			return Source{}, cleanup, fmt.Errorf("could not fetch image '%s': %w", location, err)
 		}
 
-		s, err := NewFromImage(img, o)
+		s, err := NewFromImage(img, o, location)
 		if err != nil {
 			return Source{}, cleanup, fmt.Errorf("could not populate source with image: %w", err)
 		}
@@ -87,16 +76,16 @@ func NewFromDirectory(path string) (Source, error) {
 		Resolver: &DirectoryResolver{
 			Path: path,
 		},
-		Target: DirSource{
-			Path: path,
+		Metadata: Metadata{
+			Scheme: DirectoryScheme,
+			Path:   path,
 		},
-		Scheme: DirectoryScheme,
 	}, nil
 }
 
 // NewFromImage creates a new source object tailored to catalog a given container image, relative to the
 // option given (e.g. all-layers, squashed, etc)
-func NewFromImage(img *image.Image, option Scope) (Source, error) {
+func NewFromImage(img *image.Image, option Scope, userImageStr string) (Source, error) {
 	if img == nil {
 		return Source{}, fmt.Errorf("no image given")
 	}
@@ -107,11 +96,12 @@ func NewFromImage(img *image.Image, option Scope) (Source, error) {
 	}
 
 	return Source{
-		Scope:    option,
 		Resolver: resolver,
-		Target: ImageSource{
-			Img: img,
+		Image:    img,
+		Metadata: Metadata{
+			Scope:         option,
+			Scheme:        ImageScheme,
+			ImageMetadata: NewImageMetadata(img, userImageStr),
 		},
-		Scheme: ImageScheme,
 	}, nil
 }
diff --git a/syft/source/source_test.go b/syft/source/source_test.go
index c96aadfaf..30913c91d 100644
--- a/syft/source/source_test.go
+++ b/syft/source/source_test.go
@@ -9,41 +9,41 @@ import (
 	"github.com/spf13/afero"
 )
 
-func TestNewScopeFromImageFails(t *testing.T) {
+func TestNewFromImageFails(t *testing.T) {
 	t.Run("no image given", func(t *testing.T) {
-		_, err := NewFromImage(nil, AllLayersScope)
+		_, err := NewFromImage(nil, AllLayersScope, "")
 		if err == nil {
 			t.Errorf("expected an error condition but none was given")
 		}
 	})
 }
 
-func TestNewScopeFromImageUnknownOption(t *testing.T) {
+func TestNewFromImageUnknownOption(t *testing.T) {
 	img := image.Image{}
 
 	t.Run("unknown option is an error", func(t *testing.T) {
-		_, err := NewFromImage(&img, UnknownScope)
+		_, err := NewFromImage(&img, UnknownScope, "")
 		if err == nil {
 			t.Errorf("expected an error condition but none was given")
 		}
 	})
 }
 
-func TestNewScopeFromImage(t *testing.T) {
+func TestNewFromImage(t *testing.T) {
 	layer := image.NewLayer(nil)
 	img := image.Image{
 		Layers: []*image.Layer{layer},
 	}
 
 	t.Run("create a new Locations object from image", func(t *testing.T) {
-		_, err := NewFromImage(&img, AllLayersScope)
+		_, err := NewFromImage(&img, AllLayersScope, "")
 		if err != nil {
 			t.Errorf("unexpected error when creating a new Locations from img: %+v", err)
 		}
 	})
 }
 
-func TestDirectoryScope(t *testing.T) {
+func TestNewFromDirectory(t *testing.T) {
 	testCases := []struct {
 		desc       string
 		input      string
@@ -78,16 +78,16 @@ func TestDirectoryScope(t *testing.T) {
 	}
 	for _, test := range testCases {
 		t.Run(test.desc, func(t *testing.T) {
-			p, err := NewFromDirectory(test.input)
+			src, err := NewFromDirectory(test.input)
 
 			if err != nil {
 				t.Errorf("could not create NewDirScope: %+v", err)
 			}
-			if p.Target.(DirSource).Path != test.input {
-				t.Errorf("mismatched stringer: '%s' != '%s'", p.Target.(DirSource).Path, test.input)
+			if src.Metadata.Path != test.input {
+				t.Errorf("mismatched stringer: '%s' != '%s'", src.Metadata.Path, test.input)
 			}
 
-			refs, err := p.Resolver.FilesByPath(test.inputPaths...)
+			refs, err := src.Resolver.FilesByPath(test.inputPaths...)
 			if err != nil {
 				t.Errorf("FilesByPath call produced an error: %+v", err)
 			}
@@ -100,7 +100,7 @@ func TestDirectoryScope(t *testing.T) {
 	}
 }
 
-func TestMultipleFileContentsByRefContents(t *testing.T) {
+func TestMultipleFileContentsByLocation(t *testing.T) {
 	testCases := []struct {
 		desc     string
 		input    string
@@ -136,7 +136,8 @@ func TestMultipleFileContentsByRefContents(t *testing.T) {
 			}
 			location := locations[0]
 
-			content, err := p.Resolver.FileContentsByLocation(location)
+			contents, err := p.Resolver.MultipleFileContentsByLocation([]Location{location})
+			content := contents[location]
 
 			if content != test.expected {
 				t.Errorf("unexpected contents from file: '%s' != '%s'", content, test.expected)
@@ -146,7 +147,7 @@ func TestMultipleFileContentsByRefContents(t *testing.T) {
 	}
 }
 
-func TestMultipleFileContentsByRefNoContents(t *testing.T) {
+func TestFilesByPathDoesNotExist(t *testing.T) {
 	testCases := []struct {
 		desc     string
 		input    string
diff --git a/test/integration/document_import_test.go b/test/integration/document_import_test.go
index 438cce148..50be36c9c 100644
--- a/test/integration/document_import_test.go
+++ b/test/integration/document_import_test.go
@@ -37,7 +37,7 @@ func TestCatalogFromJSON(t *testing.T) {
 			}
 
 			var buf bytes.Buffer
-			jsonPres := json.NewPresenter(expectedCatalog, *s, *expectedDistro)
+			jsonPres := json.NewPresenter(expectedCatalog, s.Metadata, *expectedDistro)
 			if err = jsonPres.Present(&buf); err != nil {
 				t.Fatalf("failed to write to presenter: %+v", err)
 			}
@@ -73,8 +73,6 @@ func TestCatalogFromJSON(t *testing.T) {
 				a := actualPackages[i]
 
 				// omit fields that should be missing
-				e.Locations = nil
-				e.FoundBy = ""
 				if e.MetadataType == pkg.JavaMetadataType {
 					metadata := e.Metadata.(pkg.JavaMetadata)
 					metadata.Parent = nil
diff --git a/test/integration/json_schema_test.go b/test/integration/json_schema_test.go
index 15970ee0e..b84bf26f8 100644
--- a/test/integration/json_schema_test.go
+++ b/test/integration/json_schema_test.go
@@ -67,7 +67,7 @@ func testJsonSchema(t *testing.T, catalog *pkg.Catalog, theScope *source.Source,
 		t.Fatalf("bad distro: %+v", err)
 	}
 
-	p := presenter.GetPresenter(presenter.JSONPresenter, *theScope, catalog, &d)
+	p := presenter.GetPresenter(presenter.JSONPresenter, theScope.Metadata, catalog, &d)
 	if p == nil {
 		t.Fatal("unable to get presenter")
 	}