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
+135 -140
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; return true
} }
}); })
} }
private static void copyJsFilesFromZip(@NotNull File file, @NotNull String outputLibraryJsPath) { private fun copyJsFilesFromZip(file: File, outputLibraryJsPath: String) {
try { try {
ZipFile zipFile = new ZipFile(file.getPath()); traverseArchive(file, outputLibraryJsPath)
try { }
traverseArchive(zipFile, outputLibraryJsPath); catch (ex: IOException) {
} LOG.error("Could not extract javascript files from " + file.getName() + ": " + ex.getMessage())
finally { }
zipFile.close();
}
throws(javaClass<IOException>())
private fun traverseArchive(file: File, outputLibraryJsPath: String) {
val zipFile = ZipFile(file.getPath())
try {
val zipEntries = zipFile.entries()
while (zipEntries.hasMoreElements()) {
val entry = zipEntries.nextElement()
val entryName = entry.getName()
if (!entry.isDirectory() && entryName.endsWith(JS_EXT)) {
val relativePath = getSuggestedPath(entryName)
if (relativePath == null) continue
val stream = zipFile.getInputStream(entry)
val content = FileUtil.loadTextAndClose(stream)
val outputFile = File(outputLibraryJsPath, relativePath)
FileUtil.writeToFile(outputFile, content)
}
} }
} }
catch (IOException ex) { finally {
LOG.error("Could extract javascript files from " + file.getName() + ": " + ex.getMessage()); zipFile.close()
} }
} }
private static void traverseArchive(@NotNull ZipFile zipFile, @NotNull String outputLibraryJsPath) throws IOException { private fun getSuggestedPath(path: String): String? {
Enumeration<? extends ZipEntry> zipEntries = zipFile.entries(); val systemIndependentPath = FileUtil.toSystemIndependentName(path)
while (zipEntries.hasMoreElements()) { if (systemIndependentPath.startsWith(METAINF)) {
ZipEntry entry = zipEntries.nextElement(); if (systemIndependentPath.startsWith(METAINF_RESOURCES)) {
String entryName = entry.getName(); return path.substring(METAINF_RESOURCES.length())
if (!entry.isDirectory() && entryName.endsWith(JS_EXT)) {
String relativePath = getSuggestedPath(entryName);
if (relativePath == null) continue;
InputStream stream = zipFile.getInputStream(entry);
String content = FileUtil.loadTextAndClose(stream);
File outputFile = new File(outputLibraryJsPath, relativePath);
FileUtil.writeToFile(outputFile, content);
} }
} return null
}
@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; return path
} }
@Nullable private fun getManifestFromJar(library: File): Manifest? {
private static Manifest getManifestFromJar(@NotNull File library) { if (!library.canRead()) return null
if (!library.canRead()) return null;
try { try {
JarFile jarFile = new JarFile(library); val jarFile = JarFile(library)
try { try {
return jarFile.getManifest(); return jarFile.getManifest()
} }
finally { finally {
jarFile.close(); jarFile.close()
} }
} }
catch (IOException ignored) { catch (ignored: IOException) {
return null; return null
} }
} }
@Nullable private fun getManifestFromDirectory(library: File): Manifest? {
private static Manifest getManifestFromDirectory(@NotNull File library) { if (!library.canRead() || !library.isDirectory()) return null
if (!library.canRead() || !library.isDirectory()) return null;
File manifestFile = new File(library, MANIFEST_PATH); val manifestFile = File(library, MANIFEST_PATH)
if (!manifestFile.exists()) return null; if (!manifestFile.exists()) return null
try { try {
InputStream inputStream = new FileInputStream(manifestFile); val inputStream = FileInputStream(manifestFile)
try { try {
return new Manifest(inputStream); return Manifest(inputStream)
} }
finally { finally {
inputStream.close(); inputStream.close()
} }
} }
catch (IOException ignored) { catch (ignored: IOException) {
LOG.warn("IOException " + ignored); LOG.warn("IOException " + ignored)
return null; return null
} }
} }
private static Manifest getManifestFromJarOrDirectory(@NotNull File library) { private fun getManifestFromJarOrDirectory(library: File): Manifest? =
return library.isDirectory() ? getManifestFromDirectory(library) : getManifestFromJar(library); if (library.isDirectory()) getManifestFromDirectory(library) else getManifestFromJar(library)
}
@Nullable private fun getManifestMainAttributesFromJarOrDirectory(library: File): Attributes? =
private static Attributes getManifestMainAttributesFromJarOrDirectory(@NotNull File library) { getManifestFromJarOrDirectory(library)?.getMainAttributes()
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 checkAttributeValue(library: File, expected: String, attributeName: Attributes.Name): Boolean {
Attributes attributes = getManifestMainAttributesFromJarOrDirectory(library); val attributes = getManifestMainAttributesFromJarOrDirectory(library)
if (attributes == null) return false; val value = attributes?.getValue(attributeName)
return value != null && value == expected
String value = attributes.getValue(attributeName);
return value != null && value.equals(expected);
} }
} }