-
Notifications
You must be signed in to change notification settings - Fork 295
/
GenerateNLVersion.kt
125 lines (111 loc) · 4.49 KB
/
GenerateNLVersion.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
import org.w3c.dom.Attr
import org.w3c.dom.Document
import org.w3c.dom.Node
import org.w3c.dom.NodeList
import java.io.File
import java.io.FileOutputStream
import java.util.concurrent.TimeUnit
import javax.xml.parsers.DocumentBuilderFactory
import javax.xml.transform.TransformerFactory
import javax.xml.transform.dom.DOMSource
import javax.xml.transform.stream.StreamResult
import javax.xml.xpath.XPathConstants
import javax.xml.xpath.XPathFactory
/**
* The scripts generates no ligature version of JetBrains Mono called JetBrains Mono NL
*
* ttx command is required to run this script
*
* @author Konstantin Bulenkov
*/
@Suppress("RECEIVER_NULLABILITY_MISMATCH_BASED_ON_JAVA_ANNOTATIONS")
fun main() {
File("./fonts/ttf/")
.listFiles { _, name -> name.endsWith(".ttf") && !name.startsWith("JetBrainsMonoNL") }
.forEach {
val ttx = it.nameWithoutExtension + ".ttx"
val dir = it.parentFile
File(dir, ttx).deleteAndLog()
val doc = ttf2Document(it)
File(dir, ttx).deleteAndLog()
if (doc != null) {
generateNoLigaturesFont(File(dir, it.name), doc)
}
}
}
fun ttf2Document(file: File): Document? {
"ttx ${file.name}".runCommand(file.parentFile)
val ttx = file.parentFile.listFiles { _, name -> name == "${file.nameWithoutExtension}.ttx" }?.first() ?: return null
val documentBuilder = DocumentBuilderFactory.newInstance().newDocumentBuilder()
return documentBuilder.parse(ttx)
}
fun generateNoLigaturesFont(file: File, doc: Document) {
val nlName = file.nameWithoutExtension.replace("JetBrainsMono", "JetBrainsMonoNL")
val ttx = "$nlName.ttx"
val ttf = "$nlName.ttf"
val dir = file.parentFile
File(dir, ttf).deleteAndLog()
doc.removeLigas("/ttFont/GlyphOrder", "GlyphID")
doc.removeLigas("/ttFont/glyf", "TTGlyph")
doc.removeLigas("/ttFont/hmtx", "mtx")
doc.removeLigas("/ttFont/post/extraNames", "psName")
doc.removeLigas("/ttFont/GDEF/GlyphClassDef", "ClassDef", attName = "glyph")
doc.removeNode("/ttFont/GPOS")
doc.removeNode("/ttFont/GSUB")
val xPath = XPathFactory.newInstance().newXPath()
val nameRecords = (xPath.evaluate("/ttFont/name/namerecord", doc, XPathConstants.NODESET) as NodeList).asList()
nameRecords.forEach {
if (!it.textContent.contains("trademark")) {
it.textContent = it.textContent
.replace("JetBrains Mono", "JetBrains Mono NL")
.replace("JetBrainsMono", "JetBrainsMonoNL")
}
}
val ttxFile = File(dir, ttx)
doc.saveAs(ttxFile)
"ttx $ttx".runCommand(dir)
ttxFile.deleteAndLog()
}
class NodeListWrapper(val nodeList: NodeList) : AbstractList<Node>(), RandomAccess {
override val size: Int
get() = nodeList.length
override fun get(index: Int): Node = nodeList.item(index)
}
////////////////////// Utility functions and data classes //////////////////////
fun NodeList.asList(): List<Node> = NodeListWrapper(this)
fun String.runCommand(workingDir: File) {
ProcessBuilder(*split(" ").toTypedArray())
.directory(workingDir)
.redirectOutput(ProcessBuilder.Redirect.INHERIT)
.redirectError(ProcessBuilder.Redirect.INHERIT)
.start()
.waitFor(1, TimeUnit.MINUTES)
}
fun Document.saveAs(file: File) {
val transformer = TransformerFactory.newInstance().newTransformer()
transformer.transform(DOMSource(this), StreamResult(FileOutputStream(file)))
}
fun Document.removeLigas(parentPath: String, nodeName: String, attName:String = "name") {
val xPath = XPathFactory.newInstance().newXPath()
val parent = xPath.evaluate(parentPath, this, XPathConstants.NODE) as Node
val nodeFilter = "$parentPath/$nodeName[substring(@$attName, string-length(@$attName)-4) = '.liga']"
val nodes = (xPath.evaluate(nodeFilter, this, XPathConstants.NODESET) as NodeList).asList()
nodes.forEach { parent.removeChild(it) }
}
fun Document.removeNode(path: String) {
val xPath = XPathFactory.newInstance().newXPath()
val parent = xPath.evaluate(path.substringBeforeLast("/"), this, XPathConstants.NODE)
if (parent is Node) {
val child = xPath.evaluate(path, this, XPathConstants.NODE)
if (child is Node) {
parent.removeChild(child)
}
}
}
fun File.deleteAndLog() {
if (!exists()) return
println("Deleting $absolutePath")
val result = delete()
println("[$result]".toUpperCase())
if (!result) deleteOnExit()
}