-
Notifications
You must be signed in to change notification settings - Fork 1
/
license.go
106 lines (96 loc) · 3.21 KB
/
license.go
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
// Copyright 2019 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
package frontend
import (
"bytes"
"context"
"sort"
"strconv"
"github.com/google/safehtml"
"github.com/khulnasoft-lab/godep/internal"
"github.com/khulnasoft-lab/godep/internal/licenses"
)
// License contains information used for a single license section.
type License struct {
*licenses.License
Anchor safehtml.Identifier
Source string
}
// LicensesDetails contains license information for a package or module.
type LicensesDetails struct {
IsRedistributable bool
Licenses []License
}
// LicenseMetadata contains license metadata that is used in the package
// header.
type LicenseMetadata struct {
Type string
Anchor safehtml.Identifier
}
// fetchLicensesDetails fetches license data for the package version specified by
// path and version from the database and returns a LicensesDetails.
func fetchLicensesDetails(ctx context.Context, ds internal.DataSource, um *internal.UnitMeta) (*LicensesDetails, error) {
u, err := ds.GetUnit(ctx, um, internal.WithMain|internal.WithLicenses, internal.BuildContext{})
if err != nil {
return nil, err
}
return &LicensesDetails{IsRedistributable: u.IsRedistributable, Licenses: transformLicenses(um.ModulePath, um.Version, u.LicenseContents)}, nil
}
// transformLicenses transforms licenses.License into a License
// by adding an anchor field.
func transformLicenses(modulePath, requestedVersion string, dbLicenses []*licenses.License) []License {
licenses := make([]License, len(dbLicenses))
var filePaths []string
for _, l := range dbLicenses {
filePaths = append(filePaths, l.FilePath)
}
anchors := licenseAnchors(filePaths)
for i, l := range dbLicenses {
l.Contents = bytes.ReplaceAll(l.Contents, []byte("\r"), nil)
licenses[i] = License{
Anchor: anchors[i],
License: l,
Source: fileSource(modulePath, requestedVersion, l.FilePath),
}
}
return licenses
}
// transformLicenseMetadata transforms licenses.Metadata into a LicenseMetadata
// by adding an anchor field.
func transformLicenseMetadata(dbLicenses []*licenses.Metadata) []LicenseMetadata {
var mds []LicenseMetadata
var filePaths []string
for _, l := range dbLicenses {
filePaths = append(filePaths, l.FilePath)
}
anchors := licenseAnchors(filePaths)
for i, l := range dbLicenses {
anchor := anchors[i]
for _, typ := range l.Types {
mds = append(mds, LicenseMetadata{
Type: typ,
Anchor: anchor,
})
}
}
return mds
}
// licenseAnchors returns anchors (HTML identifiers) for all the paths, in the
// same order. If the paths are unique, it ensures that the resulting anchors
// are unique. The argument is modified.
func licenseAnchors(paths []string) []safehtml.Identifier {
// Remember the original index of each path.
index := map[string]int{}
for i, p := range paths {
index[p] = i
}
// Pick a canonical order for the paths, so we assign the same anchors
// the same set of paths regardless of the order they're given to use.
sort.Strings(paths)
ids := make([]safehtml.Identifier, len(paths))
for i, p := range paths {
ids[index[p]] = safehtml.IdentifierFromConstantPrefix("lic", strconv.Itoa(i))
}
return ids
}