149 lines
4.5 KiB
Go
149 lines
4.5 KiB
Go
// Copyright 2021 Google LLC
|
|
//
|
|
// Licensed under the Apache License, Version 2.0 (the "License");
|
|
// you may not use this file except in compliance with the License.
|
|
// You may obtain a copy of the License at
|
|
//
|
|
// http://www.apache.org/licenses/LICENSE-2.0
|
|
//
|
|
// Unless required by applicable law or agreed to in writing, software
|
|
// distributed under the License is distributed on an "AS IS" BASIS,
|
|
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
// See the License for the specific language governing permissions and
|
|
// limitations under the License.
|
|
|
|
package compliance
|
|
|
|
import (
|
|
"fmt"
|
|
"sort"
|
|
"strings"
|
|
)
|
|
|
|
// Resolution describes an action to resolve one or more license conditions.
|
|
//
|
|
// `AttachesTo` identifies the target node that when distributed triggers the action.
|
|
// `ActsOn` identifies the target node that is the object of the action.
|
|
// `Resolves` identifies one or more license conditions that the action resolves.
|
|
//
|
|
// e.g. Suppose an MIT library is linked to a binary that also links to GPL code.
|
|
//
|
|
// A resolution would attach to the binary to share (act on) the MIT library to
|
|
// resolve the restricted condition originating from the GPL code.
|
|
type Resolution struct {
|
|
attachesTo, actsOn *TargetNode
|
|
cs LicenseConditionSet
|
|
}
|
|
|
|
// AttachesTo returns the target node the resolution attaches to.
|
|
func (r Resolution) AttachesTo() *TargetNode {
|
|
return r.attachesTo
|
|
}
|
|
|
|
// ActsOn returns the target node that must be acted on to resolve the condition.
|
|
//
|
|
// i.e. The node for which notice must be given or whose source must be shared etc.
|
|
func (r Resolution) ActsOn() *TargetNode {
|
|
return r.actsOn
|
|
}
|
|
|
|
// Resolves returns the set of license condition the resolution satisfies.
|
|
func (r Resolution) Resolves() LicenseConditionSet {
|
|
return r.cs
|
|
}
|
|
|
|
// asString returns a string representation of the resolution.
|
|
func (r Resolution) asString() string {
|
|
var sb strings.Builder
|
|
names := r.cs.Names()
|
|
sort.Strings(names)
|
|
fmt.Fprintf(&sb, "%s -> %s{%s}", r.attachesTo.name, r.actsOn.name, strings.Join(names, ", "))
|
|
return sb.String()
|
|
}
|
|
|
|
// ResolutionList represents a partial order of Resolutions ordered by
|
|
// AttachesTo() and ActsOn() leaving `Resolves()` unordered.
|
|
type ResolutionList []Resolution
|
|
|
|
// Len returns the count of elements in the list.
|
|
func (l ResolutionList) Len() int { return len(l) }
|
|
|
|
// Swap rearranges 2 elements so that each occupies the other's former position.
|
|
func (l ResolutionList) Swap(i, j int) { l[i], l[j] = l[j], l[i] }
|
|
|
|
// Less returns true when the `i`th element is lexicographically less than tht `j`th.
|
|
func (l ResolutionList) Less(i, j int) bool {
|
|
if l[i].attachesTo.name == l[j].attachesTo.name {
|
|
return l[i].actsOn.name < l[j].actsOn.name
|
|
}
|
|
return l[i].attachesTo.name < l[j].attachesTo.name
|
|
}
|
|
|
|
// String returns a string representation of the list.
|
|
func (rl ResolutionList) String() string {
|
|
var sb strings.Builder
|
|
fmt.Fprintf(&sb, "[")
|
|
sep := ""
|
|
for _, r := range rl {
|
|
fmt.Fprintf(&sb, "%s%s", sep, r.asString())
|
|
sep = ", "
|
|
}
|
|
fmt.Fprintf(&sb, "]")
|
|
return sb.String()
|
|
}
|
|
|
|
// AllConditions returns the union of all license conditions resolved by any
|
|
// element of the list.
|
|
func (rl ResolutionList) AllConditions() LicenseConditionSet {
|
|
result := NewLicenseConditionSet()
|
|
for _, r := range rl {
|
|
result = result.Union(r.cs)
|
|
}
|
|
return result
|
|
}
|
|
|
|
// ByName returns the sub-list of resolutions resolving conditions matching
|
|
// `names`.
|
|
func (rl ResolutionList) Matching(conditions LicenseConditionSet) ResolutionList {
|
|
result := make(ResolutionList, 0, rl.CountMatching(conditions))
|
|
for _, r := range rl {
|
|
if r.Resolves().MatchesAnySet(conditions) {
|
|
result = append(result, Resolution{r.attachesTo, r.actsOn, r.cs.MatchingAnySet(conditions)})
|
|
}
|
|
}
|
|
return result
|
|
}
|
|
|
|
// CountMatching returns the number of resolutions resolving conditions matching
|
|
// `conditions`.
|
|
func (rl ResolutionList) CountMatching(conditions LicenseConditionSet) int {
|
|
c := 0
|
|
for _, r := range rl {
|
|
if r.Resolves().MatchesAnySet(conditions) {
|
|
c++
|
|
}
|
|
}
|
|
return c
|
|
}
|
|
|
|
// ByActsOn returns the sub-list of resolutions matching `actsOn`.
|
|
func (rl ResolutionList) ByActsOn(actsOn *TargetNode) ResolutionList {
|
|
result := make(ResolutionList, 0, rl.CountByActsOn(actsOn))
|
|
for _, r := range rl {
|
|
if r.actsOn == actsOn {
|
|
result = append(result, r)
|
|
}
|
|
}
|
|
return result
|
|
}
|
|
|
|
// CountByActsOn returns the number of resolutions matching `actsOn`.
|
|
func (rl ResolutionList) CountByActsOn(actsOn *TargetNode) int {
|
|
c := 0
|
|
for _, r := range rl {
|
|
if r.actsOn == actsOn {
|
|
c++
|
|
}
|
|
}
|
|
return c
|
|
}
|