azalea/kotlin-fork
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Rewrite to Kotlin: LibraryUtils

Browse Source
This commit is contained in:
Michael Nedzelsky
2014-12-09 19:18:11 +03:00
parent 5675da93f3
commit 1c9039d23b
1 changed files with 135 additions and 140 deletions
Download Patch File Download Diff File Expand all files Collapse all files
compiler/util/src/org/jetbrains/jet/utils/LibraryUtils.kt
+143 -148
View File
@@ -14,222 +14,217 @@
* limitations under the License. * limitations under the License.
*/ */
package org.jetbrains.jet.utils; package org.jetbrains.jet.utils
import com.intellij.openapi.diagnostic.Logger; import com.intellij.openapi.diagnostic.Logger
import com.intellij.openapi.util.io.FileUtil; import com.intellij.openapi.util.io.FileUtil
import com.intellij.openapi.vfs.VirtualFile; import com.intellij.openapi.vfs.VirtualFile
import com.intellij.util.Processor; import com.intellij.util.Processor
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import java.io.*; import java.io.*
import java.util.Enumeration; import java.util.Enumeration
import java.util.List; import java.util.Properties
import java.util.Properties; import java.util.jar.Attributes
import java.util.jar.Attributes; import java.util.jar.JarFile
import java.util.jar.JarFile; import java.util.jar.Manifest
import java.util.jar.Manifest; import java.util.zip.ZipEntry
import java.util.zip.ZipEntry; import java.util.zip.ZipFile
import java.util.zip.ZipFile; import kotlin.platform.platformStatic
public class LibraryUtils { public object LibraryUtils {
private static final Logger LOG = Logger.getInstance(LibraryUtils.class); private val LOG = Logger.getInstance(javaClass<LibraryUtils>())
public static final String KOTLIN_JS_MODULE_NAME = "Kotlin-JS-Module-Name"; public val KOTLIN_JS_MODULE_NAME: String = "Kotlin-JS-Module-Name"
private static final String TITLE_KOTLIN_JAVASCRIPT_STDLIB; private var TITLE_KOTLIN_JAVASCRIPT_STDLIB: String
private static final String TITLE_KOTLIN_JAVASCRIPT_LIB; private var TITLE_KOTLIN_JAVASCRIPT_LIB: String
private static final String JS_EXT = ".js"; private val JS_EXT = ".js"
private static final String METAINF = "META-INF/"; private val METAINF = "META-INF/"
private static final String MANIFEST_PATH = METAINF + "MANIFEST.MF"; private val MANIFEST_PATH = "${METAINF}MANIFEST.MF"
private static final String METAINF_RESOURCES = METAINF + "resources/"; private val METAINF_RESOURCES = "${METAINF}resources/"
private static final Attributes.Name KOTLIN_JS_MODULE_ATTRIBUTE_NAME = new Attributes.Name(KOTLIN_JS_MODULE_NAME); private val KOTLIN_JS_MODULE_ATTRIBUTE_NAME = Attributes.Name(KOTLIN_JS_MODULE_NAME);
static { {
String jsStdLib = ""; var jsStdLib = ""
String jsLib = ""; var jsLib = ""
InputStream manifestProperties = LibraryUtils.class.getResourceAsStream("/manifest.properties"); val manifestProperties = javaClass<LibraryUtils>().getResourceAsStream("/manifest.properties")
if (manifestProperties != null) { if (manifestProperties != null) {
try { try {
Properties properties = new Properties(); val properties = Properties()
properties.load(manifestProperties); properties.load(manifestProperties)
jsStdLib = properties.getProperty("manifest.impl.title.kotlin.javascript.stdlib"); jsStdLib = properties.getProperty("manifest.impl.title.kotlin.javascript.stdlib")
jsLib = properties.getProperty("manifest.spec.title.kotlin.javascript.lib"); jsLib = properties.getProperty("manifest.spec.title.kotlin.javascript.lib")
} }
catch (IOException e) { catch (e: IOException) {
LOG.error(e); LOG.error(e)
} }
} }
else { else {
LOG.error("Resource 'manifest.properties' not found."); LOG.error("Resource 'manifest.properties' not found.")
} }
TITLE_KOTLIN_JAVASCRIPT_STDLIB = jsStdLib; TITLE_KOTLIN_JAVASCRIPT_STDLIB = jsStdLib
TITLE_KOTLIN_JAVASCRIPT_LIB = jsLib; TITLE_KOTLIN_JAVASCRIPT_LIB = jsLib
} }
private LibraryUtils() {} platformStatic
public fun getJarFile(classesRoots: List<VirtualFile>, jarName: String): VirtualFile? {
public static VirtualFile getJarFile(@NotNull List<VirtualFile> classesRoots, @NotNull String jarName) { for (root in classesRoots) {
for (VirtualFile root : classesRoots) { if (root.getName() == jarName) {
if (root.getName().equals(jarName)) { return root
return root;
} }
} }
return null; return null
} }
@Nullable platformStatic
public static String getKotlinJsModuleName(@NotNull File library) { public fun getKotlinJsModuleName(library: File): String? {
Attributes attributes = getManifestMainAttributesFromJarOrDirectory(library); return getManifestMainAttributesFromJarOrDirectory(library)?.getValue(KOTLIN_JS_MODULE_ATTRIBUTE_NAME)
return attributes != null ? attributes.getValue(KOTLIN_JS_MODULE_ATTRIBUTE_NAME) : null;
} }
public static boolean isKotlinJavascriptLibrary(@NotNull File library) { platformStatic
return checkAttributeValue(library, TITLE_KOTLIN_JAVASCRIPT_LIB, Attributes.Name.SPECIFICATION_TITLE); public fun isKotlinJavascriptLibrary(library: File): Boolean {
return checkAttributeValue(library, TITLE_KOTLIN_JAVASCRIPT_LIB, Attributes.Name.SPECIFICATION_TITLE)
} }
public static boolean isKotlinJavascriptStdLibrary(@NotNull File library) { platformStatic
return checkAttributeValue(library, TITLE_KOTLIN_JAVASCRIPT_STDLIB, Attributes.Name.IMPLEMENTATION_TITLE); public fun isKotlinJavascriptStdLibrary(library: File): Boolean {
return checkAttributeValue(library, TITLE_KOTLIN_JAVASCRIPT_STDLIB, Attributes.Name.IMPLEMENTATION_TITLE)
} }
public static void copyJsFilesFromLibraries(@NotNull List<String> libraries, @NotNull String outputLibraryJsPath) { platformStatic
for(String library : libraries) { public fun copyJsFilesFromLibraries(libraries: List<String>, outputLibraryJsPath: String) {
File file = new File(library); for (library in libraries) {
assert file.exists() : "Library " + library + " not found"; val file = File(library)
assert(file.exists()) { "Library " + library + " not found" }
if (file.isDirectory()) { if (file.isDirectory()) {
copyJsFilesFromDirectory(file, outputLibraryJsPath); copyJsFilesFromDirectory(file, outputLibraryJsPath)
} }
else { else {
copyJsFilesFromZip(file, outputLibraryJsPath); copyJsFilesFromZip(file, outputLibraryJsPath)
} }
} }
} }
private static void copyJsFilesFromDirectory(@NotNull final File dir, @NotNull final String outputLibraryJsPath) { private fun copyJsFilesFromDirectory(dir: File, outputLibraryJsPath: String) {
FileUtil.processFilesRecursively(dir, new Processor<File>() { FileUtil.processFilesRecursively(dir, object : Processor<File> {
@Override override fun process(file: File): Boolean {
public boolean process(File file) { var relativePath = FileUtil.getRelativePath(dir, file)
String relativePath = FileUtil.getRelativePath(dir, file); assert(relativePath != null) { "relativePath should not be null " + dir + " " + file }
assert relativePath != null : "relativePath should not be null " + dir + " " + file; if (file.isFile() && relativePath!!.endsWith(JS_EXT)) {
if (file.isFile() && relativePath.endsWith(JS_EXT)) { relativePath = getSuggestedPath(relativePath)
relativePath = getSuggestedPath(relativePath); if (relativePath == null) return true
if (relativePath == null) return true;
try { try {
FileUtil.copy(file, new File(outputLibraryJsPath, relativePath)); val copyFile = File(outputLibraryJsPath, relativePath)
FileUtil.copy(file, copyFile)
} }
catch (IOException ex) { catch (ex: IOException) {
LOG.error("Could not copy " + relativePath + " from " + dir + ": " + ex.getMessage()); LOG.error("Could not copy " + relativePath + " from " + dir + ": " + ex.getMessage())
}
}
return true;
}
});
} }
private static void copyJsFilesFromZip(@NotNull File file, @NotNull String outputLibraryJsPath) {
try {
ZipFile zipFile = new ZipFile(file.getPath());
try {
traverseArchive(zipFile, outputLibraryJsPath);
} }
finally { return true
zipFile.close();
}
}
catch (IOException ex) {
LOG.error("Could extract javascript files from " + file.getName() + ": " + ex.getMessage());
} }
})
} }
private static void traverseArchive(@NotNull ZipFile zipFile, @NotNull String outputLibraryJsPath) throws IOException { private fun copyJsFilesFromZip(file: File, outputLibraryJsPath: String) {
Enumeration<? extends ZipEntry> zipEntries = zipFile.entries(); try {
traverseArchive(file, outputLibraryJsPath)
}
catch (ex: IOException) {
LOG.error("Could not extract javascript files from " + file.getName() + ": " + ex.getMessage())
}
}
throws(javaClass<IOException>())
private fun traverseArchive(file: File, outputLibraryJsPath: String) {
val zipFile = ZipFile(file.getPath())
try {
val zipEntries = zipFile.entries()
while (zipEntries.hasMoreElements()) { while (zipEntries.hasMoreElements()) {
ZipEntry entry = zipEntries.nextElement(); val entry = zipEntries.nextElement()
String entryName = entry.getName(); val entryName = entry.getName()
if (!entry.isDirectory() && entryName.endsWith(JS_EXT)) { if (!entry.isDirectory() && entryName.endsWith(JS_EXT)) {
String relativePath = getSuggestedPath(entryName); val relativePath = getSuggestedPath(entryName)
if (relativePath == null) continue; if (relativePath == null) continue
InputStream stream = zipFile.getInputStream(entry); val stream = zipFile.getInputStream(entry)
String content = FileUtil.loadTextAndClose(stream); val content = FileUtil.loadTextAndClose(stream)
File outputFile = new File(outputLibraryJsPath, relativePath); val outputFile = File(outputLibraryJsPath, relativePath)
FileUtil.writeToFile(outputFile, content); FileUtil.writeToFile(outputFile, content)
} }
} }
} }
@Nullable
private static String getSuggestedPath(@NotNull String path) {
if (path.startsWith(METAINF)) {
if (path.startsWith(METAINF_RESOURCES)) {
return path.substring(METAINF_RESOURCES.length());
}
return null;
}
return path;
}
@Nullable
private static Manifest getManifestFromJar(@NotNull File library) {
if (!library.canRead()) return null;
try {
JarFile jarFile = new JarFile(library);
try {
return jarFile.getManifest();
}
finally { finally {
jarFile.close(); zipFile.close()
}
}
catch (IOException ignored) {
return null;
} }
} }
@Nullable private fun getSuggestedPath(path: String): String? {
private static Manifest getManifestFromDirectory(@NotNull File library) { val systemIndependentPath = FileUtil.toSystemIndependentName(path)
if (!library.canRead() || !library.isDirectory()) return null; if (systemIndependentPath.startsWith(METAINF)) {
if (systemIndependentPath.startsWith(METAINF_RESOURCES)) {
return path.substring(METAINF_RESOURCES.length())
}
return null
}
File manifestFile = new File(library, MANIFEST_PATH); return path
if (!manifestFile.exists()) return null; }
private fun getManifestFromJar(library: File): Manifest? {
if (!library.canRead()) return null
try { try {
InputStream inputStream = new FileInputStream(manifestFile); val jarFile = JarFile(library)
try { try {
return new Manifest(inputStream); return jarFile.getManifest()
} }
finally { finally {
inputStream.close(); jarFile.close()
} }
} }
catch (IOException ignored) { catch (ignored: IOException) {
LOG.warn("IOException " + ignored); return null
return null;
} }
} }
private static Manifest getManifestFromJarOrDirectory(@NotNull File library) { private fun getManifestFromDirectory(library: File): Manifest? {
return library.isDirectory() ? getManifestFromDirectory(library) : getManifestFromJar(library); if (!library.canRead() || !library.isDirectory()) return null
val manifestFile = File(library, MANIFEST_PATH)
if (!manifestFile.exists()) return null
try {
val inputStream = FileInputStream(manifestFile)
try {
return Manifest(inputStream)
}
finally {
inputStream.close()
}
}
catch (ignored: IOException) {
LOG.warn("IOException " + ignored)
return null
}
} }
@Nullable private fun getManifestFromJarOrDirectory(library: File): Manifest? =
private static Attributes getManifestMainAttributesFromJarOrDirectory(@NotNull File library) { if (library.isDirectory()) getManifestFromDirectory(library) else getManifestFromJar(library)
Manifest manifest = getManifestFromJarOrDirectory(library);
return manifest != null ? manifest.getMainAttributes() : null;
}
private static boolean checkAttributeValue(@NotNull File library, String expected, @NotNull Attributes.Name attributeName) { private fun getManifestMainAttributesFromJarOrDirectory(library: File): Attributes? =
Attributes attributes = getManifestMainAttributesFromJarOrDirectory(library); getManifestFromJarOrDirectory(library)?.getMainAttributes()
if (attributes == null) return false;
String value = attributes.getValue(attributeName); private fun checkAttributeValue(library: File, expected: String, attributeName: Attributes.Name): Boolean {
return value != null && value.equals(expected); val attributes = getManifestMainAttributesFromJarOrDirectory(library)
val value = attributes?.getValue(attributeName)
return value != null && value == expected
} }
} }