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
|
package com.github.shyiko.ktlint.ruleset.standard
import com.github.shyiko.ktlint.core.Rule
import org.jetbrains.kotlin.com.intellij.lang.ASTNode
import org.jetbrains.kotlin.com.intellij.lang.FileASTNode
import org.jetbrains.kotlin.com.intellij.psi.PsiComment
import org.jetbrains.kotlin.com.intellij.psi.impl.source.tree.LeafPsiElement
import org.jetbrains.kotlin.kdoc.psi.api.KDoc
import org.jetbrains.kotlin.psi.KtImportDirective
import org.jetbrains.kotlin.psi.KtPackageDirective
import org.jetbrains.kotlin.psi.psiUtil.getPrevSiblingIgnoringWhitespaceAndComments
import org.jetbrains.kotlin.psi.psiUtil.startOffset
import org.jetbrains.kotlin.psi.stubs.elements.KtStubElementTypes
class MaxLineLengthRule : Rule("max-line-length"), Rule.Modifier.Last {
private var maxLineLength: Int = -1
private var rangeTree = RangeTree()
override fun visit(
node: ASTNode,
autoCorrect: Boolean,
emit: (offset: Int, errorMessage: String, canBeAutoCorrected: Boolean) -> Unit
) {
if (node.elementType == KtStubElementTypes.FILE) {
val ec = EditorConfig.from(node as FileASTNode)
maxLineLength = ec.maxLineLength
if (maxLineLength <= 0) {
return
}
val errorOffset = arrayListOf<Int>()
val text = node.text
val lines = text.split("\n")
var offset = 0
for (line in lines) {
if (line.length > maxLineLength) {
val el = node.psi.findElementAt(offset + line.length - 1)!!
if (!el.isPartOf(KDoc::class)) {
if (!el.isPartOf(PsiComment::class)) {
if (!el.isPartOf(KtPackageDirective::class) && !el.isPartOf(KtImportDirective::class)) {
// fixme:
// normally we would emit here but due to API limitations we need to hold off until
// node spanning the same offset is 'visit'ed
// (for ktlint-disable directive to have effect (when applied))
// this will be rectified in the upcoming release(s)
errorOffset.add(offset)
}
} else {
// if comment is the only thing on the line - fine, otherwise emit an error
val prevLeaf = el.getPrevSiblingIgnoringWhitespaceAndComments(false)
if (prevLeaf != null && prevLeaf.startOffset >= offset) {
// fixme:
// normally we would emit here but due to API limitations we need to hold off until
// node spanning the same offset is 'visit'ed
// (for ktlint-disable directive to have effect (when applied))
// this will be rectified in the upcoming release(s)
errorOffset.add(offset)
}
}
}
}
offset += line.length + 1
}
rangeTree = RangeTree(errorOffset)
} else if (!rangeTree.isEmpty() && node.psi is LeafPsiElement) {
rangeTree
.query(node.startOffset, node.startOffset + node.textLength)
.forEach { offset ->
emit(offset, "Exceeded max line length ($maxLineLength)", false)
}
}
}
}
class RangeTree(seq: List<Int> = emptyList()) {
private var emptyArrayView = ArrayView(0, 0)
private var arr: IntArray = seq.toIntArray()
init {
if (arr.isNotEmpty()) {
arr.reduce { p, n -> require(p <= n) { "Input must be sorted" }; n }
}
}
// runtime: O(log(n)+k), where k is number of matching points
// space: O(1)
fun query(vmin: Int, vmax: Int): ArrayView {
var r = arr.size - 1
if (r == -1 || vmax < arr[0] || arr[r] < vmin) {
return emptyArrayView
}
// binary search for min(arr[l] >= vmin)
var l = 0
while (l < r) {
val m = (r + l) / 2
if (vmax < arr[m]) {
r = m - 1
} else if (arr[m] < vmin) {
l = m + 1
} else {
// arr[l] ?<=? vmin <= arr[m] <= vmax ?<=? arr[r]
if (vmin <= arr[l]) break else l++ // optimization
r = m
}
}
if (l > r || arr[l] < vmin) {
return emptyArrayView
}
// find max(k) such as arr[k] < vmax
var k = l
while (k < arr.size) {
if (arr[k] >= vmax) {
break
}
k++
}
return ArrayView(l, k)
}
fun isEmpty() = arr.isEmpty()
inner class ArrayView(private var l: Int, private val r: Int) {
val size: Int = r - l
fun get(i: Int): Int {
if (i < 0 || i >= size) {
throw IndexOutOfBoundsException()
}
return arr[l + i]
}
inline fun forEach(cb: (v: Int) -> Unit) {
var i = 0
while (i < size) {
cb(get(i++))
}
}
override fun toString(): String {
if (l == r) {
return "[]"
}
val sb = StringBuilder("[")
var i = l
while (i < r) {
sb.append(arr[i]).append(", ")
i++
}
sb.replace(sb.length - 2, sb.length, "")
sb.append("]")
return sb.toString()
}
}
}
|
