forked from oss-review-toolkit/ort
-
Notifications
You must be signed in to change notification settings - Fork 0
/
ReportTableModel.kt
266 lines (226 loc) · 8.41 KB
/
ReportTableModel.kt
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
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
/*
* Copyright (C) 2017-2019 HERE Europe B.V.
*
* 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
*
* https://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.
*
* SPDX-License-Identifier: Apache-2.0
* License-Filename: LICENSE
*/
package org.ossreviewtoolkit.reporter
import java.util.SortedMap
import java.util.SortedSet
import org.ossreviewtoolkit.model.Identifier
import org.ossreviewtoolkit.model.OrtResult
import org.ossreviewtoolkit.model.Project
import org.ossreviewtoolkit.model.RemoteArtifact
import org.ossreviewtoolkit.model.RuleViolation
import org.ossreviewtoolkit.model.ScanResult
import org.ossreviewtoolkit.model.Severity
import org.ossreviewtoolkit.model.VcsInfo
import org.ossreviewtoolkit.model.config.PathExclude
import org.ossreviewtoolkit.model.config.RepositoryConfiguration
import org.ossreviewtoolkit.model.config.ScopeExclude
import org.ossreviewtoolkit.model.licenses.ResolvedLicense
import org.ossreviewtoolkit.utils.common.zipWithCollections
import org.ossreviewtoolkit.utils.common.zipWithDefault
import org.ossreviewtoolkit.utils.spdx.SpdxExpression
fun Collection<ReportTableModel.ResolvableIssue>.containsUnresolved() = any { !it.isResolved }
fun <K> Map<K, Collection<ReportTableModel.ResolvableIssue>>.containsUnresolved() =
any { it.value.containsUnresolved() }
data class ReportTableModel(
/**
* The [VcsInfo] for the scanned project.
*/
val vcsInfo: VcsInfo,
/**
* The [RepositoryConfiguration] of the scanned project.
*/
val config: RepositoryConfiguration,
/**
* A list containing all evaluator rule violations. `null` if no evaluator result is available.
*/
val ruleViolations: List<ResolvableViolation>?,
/**
* A [IssueTable] containing all dependencies that caused issues.
*/
val issueSummary: IssueTable,
/**
* A [SummaryTable] containing the dependencies of all [Project]s.
*/
val summary: SummaryTable,
/**
* The [ProjectTable]s containing the dependencies for each [Project].
*/
val projectDependencies: SortedMap<Project, ProjectTable>,
/**
* The labels from [OrtResult.labels].
*/
val labels: Map<String, String>
) {
data class ProjectTable(
/**
* The dependencies of this project.
*/
val rows: List<DependencyRow>,
/**
* The path to the directory containing the definition file of the project, relative to the analyzer root,
* see [OrtResult.getDefinitionFilePathRelativeToAnalyzerRoot].
*/
val fullDefinitionFilePath: String,
/**
* Information about if and why the project is excluded by [PathExclude]s.
*/
val pathExcludes: List<PathExclude>
) {
fun isExcluded() = pathExcludes.isNotEmpty()
}
data class DependencyRow(
/**
* The identifier of the package.
*/
val id: Identifier,
/**
* The remote artifact where the source package can be downloaded.
*/
val sourceArtifact: RemoteArtifact,
/**
* The VCS information of the package.
*/
val vcsInfo: VcsInfo,
/**
* The scopes the package is used in.
*/
val scopes: SortedMap<String, List<ScopeExclude>>,
/**
* The concluded license of the package.
*/
val concludedLicense: SpdxExpression?,
/**
* The licenses declared by the package.
*/
val declaredLicenses: List<ResolvedLicense>,
/**
* The detected licenses aggregated from all [ScanResult]s for this package.
*/
val detectedLicenses: List<ResolvedLicense>,
/**
* The effective license of the package derived from the licenses of the license sources chosen by a
* LicenseView, with optional choices applied.
*/
val effectiveLicense: SpdxExpression?,
/**
* All analyzer issues related to this package.
*/
val analyzerIssues: List<ResolvableIssue>,
/**
* All scan issues related to this package.
*/
val scanIssues: List<ResolvableIssue>
)
data class SummaryTable(
val rows: List<SummaryRow>
)
data class SummaryRow(
/**
* The identifier of the package.
*/
val id: Identifier,
/**
* The scopes the package is used in, grouped by the [Identifier] of the [Project] they appear in.
*/
val scopes: SortedMap<Identifier, SortedMap<String, List<ScopeExclude>>>,
/**
* The concluded licenses of the package.
*/
val concludedLicenses: Set<SpdxExpression>,
/**
* The licenses declared by the package.
*/
val declaredLicenses: SortedSet<String>,
/**
* The detected licenses aggregated from all [ScanResult]s for this package.
*/
val detectedLicenses: SortedSet<String>,
/**
* All analyzer issues related to this package, grouped by the [Identifier] of the [Project] they appear in.
*/
val analyzerIssues: SortedMap<Identifier, List<ResolvableIssue>>,
/**
* All scan issues related to this package, grouped by the [Identifier] of the [Project] they appear in.
*/
val scanIssues: SortedMap<Identifier, List<ResolvableIssue>>
) {
fun merge(other: SummaryRow) =
SummaryRow(
id = id,
scopes = scopes.zipWithDefault(other.scopes, sortedMapOf()) { left, right ->
left.zipWithCollections(right).toSortedMap()
}.toSortedMap(),
concludedLicenses = (concludedLicenses + other.concludedLicenses),
declaredLicenses = (declaredLicenses + other.declaredLicenses).toSortedSet(),
detectedLicenses = (detectedLicenses + other.detectedLicenses).toSortedSet(),
analyzerIssues = analyzerIssues.zipWithCollections(other.analyzerIssues).toSortedMap(),
scanIssues = scanIssues.zipWithCollections(other.scanIssues).toSortedMap()
)
}
data class IssueTable(
val rows: List<IssueRow>
) {
val errorCount: Int
val warningCount: Int
val hintCount: Int
init {
val unresolvedIssues = rows.flatMap {
it.analyzerIssues.flatMap { (_, issues) -> issues } +
it.scanIssues.flatMap { (_, issues) -> issues }
}.filterNot { it.isResolved }.groupBy { it.severity }
errorCount = unresolvedIssues[Severity.ERROR].orEmpty().size
warningCount = unresolvedIssues[Severity.WARNING].orEmpty().size
hintCount = unresolvedIssues[Severity.HINT].orEmpty().size
}
}
data class IssueRow(
/**
* The identifier of the package.
*/
val id: Identifier,
/**
* All analyzer issues related to this package, grouped by the [Identifier] of the [Project] they appear in.
*/
val analyzerIssues: SortedMap<Identifier, List<ResolvableIssue>>,
/**
* All scan issues related to this package, grouped by the [Identifier] of the [Project] they appear in.
*/
val scanIssues: SortedMap<Identifier, List<ResolvableIssue>>
) {
fun merge(other: IssueRow): IssueRow =
IssueRow(
id = id,
analyzerIssues = analyzerIssues.zipWithCollections(other.analyzerIssues).toSortedMap(),
scanIssues = scanIssues.zipWithCollections(other.scanIssues).toSortedMap()
)
}
data class ResolvableIssue(
val source: String,
val description: String,
val resolutionDescription: String,
val isResolved: Boolean,
val severity: Severity,
val howToFix: String
)
data class ResolvableViolation(
val violation: RuleViolation,
val resolutionDescription: String,
val isResolved: Boolean
)
}