release v1.0

build.gradle.kts

@@ -0,0 +1,49 @@
+import org.jetbrains.kotlin.gradle.tasks.KotlinCompile
+
+plugins {
+    kotlin("jvm") version "1.3.41"
+    `maven-publish`
+}
+
+
+
+group = "org.jetbrains"
+version = "1.0"
+
+val sourcesJar by tasks.registering(Jar::class) {
+    archiveClassifier.set("sources")
+    from(sourceSets.main.get().allSource)
+}
+
+publishing {
+    publications {
+        register<MavenPublication>("mavenJava") {
+            from(components["java"])
+            artifact(sourcesJar.get())
+        }
+    }
+}
+
+
+
+repositories {
+    mavenCentral()
+}
+
+tasks.withType<Test> {
+    useTestNG()
+}
+
+dependencies {
+    implementation("org.jetbrains.kotlin:kotlin-stdlib")
+    implementation("com.google.code.gson:gson:2.5")
+    implementation("org.slf4j:slf4j-api:1.7.25")
+    implementation("org.slf4j:slf4j-simple:1.7.25")
+
+    testImplementation("org.testng:testng:6.14.3")
+    testImplementation("org.jmock:jmock:2.5.1")
+}
+
+tasks.withType<KotlinCompile> {
+    kotlinOptions.jvmTarget = "1.8"
+}

settings.gradle.kts

@@ -0,0 +1,2 @@
+rootProject.name = "dotnet-discovery"
+

src/main/kotlin/org/jetbrains/dotnet/common/FileUtils.kt

@@ -0,0 +1,28 @@
+package org.jetbrains.dotnet.common
+
+import java.nio.file.Path
+
+internal fun Path.toNormalizedUnixString(): String = this.normalize().toString().toSystem(true)
+
+internal fun String.toSystem(isUnix: Boolean = !isWindows()): String {
+    val separators = getSeparators(isUnix)
+    return this.replace(separators.first, separators.second)
+}
+
+internal fun Path.toSystem(isUnix: Boolean = !isWindows()) =
+    Path.of(this.toString().toSystem(isUnix))
+
+
+private fun isWindows(): Boolean {
+    return System.getProperty("os.name").toLowerCase().contains("win")
+}
+
+private fun getSeparators(isUnix: Boolean) =
+    if (isUnix) {
+        WINDOWS_SEPARATOR to UNIX_SEPARATOR
+    } else {
+        UNIX_SEPARATOR to WINDOWS_SEPARATOR
+    }
+
+private const val WINDOWS_SEPARATOR = "\\"
+private const val UNIX_SEPARATOR = "/"

src/main/kotlin/org/jetbrains/dotnet/common/XPathReader.kt

@@ -0,0 +1,27 @@
+package org.jetbrains.dotnet.common
+
+import org.w3c.dom.Document
+import org.w3c.dom.Element
+import org.w3c.dom.NodeList
+import javax.xml.xpath.XPathConstants
+import javax.xml.xpath.XPathFactory
+
+open class XPathReader {
+
+    private val xPath = XPathFactory.newInstance().newXPath()
+
+    protected fun getElements(doc: Document, xpath: String): Sequence<Element> = sequence {
+        val nodes = xPath.evaluate(xpath, doc, XPathConstants.NODESET) as NodeList
+        for (i in 0 until nodes.length) {
+            val element = nodes.item(i) as Element
+            yield(element)
+        }
+    }
+
+    protected fun getContents(doc: Document, xpath: String): Sequence<String> =
+        getElements(doc, xpath).map { it.textContent }.filter { !it.isNullOrBlank() }
+
+    protected fun getAttributes(doc: Document, xpath: String, attributeName: String): Sequence<String> =
+        getElements(doc, xpath).map { it.getAttribute(attributeName) }.filter { !it.isNullOrBlank() }
+
+}

src/main/kotlin/org/jetbrains/dotnet/common/XmlDocumentServiceImpl.kt

@@ -22,7 +22,6 @@ class XmlDocumentServiceImpl : XmlDocumentService {
         } catch (ex: ParserConfigurationException) {
             throw IllegalStateException("Error during creating xml document")
         }
-
         return docBuilder.newDocument()
     }
 

src/main/kotlin/org/jetbrains/dotnet/discovery/FileStreamFactory.kt → src/main/kotlin/org/jetbrains/dotnet/discovery/FileProjectStreamFactory.kt

@@ -4,10 +4,11 @@ import org.slf4j.Logger
 import org.slf4j.LoggerFactory
 import java.io.File
 import java.io.InputStream
+import java.nio.file.Path
 
-class FileStreamFactory(private val baseDirectory: File) : StreamFactory {
-    override fun tryCreate(path: String): InputStream? {
-        val file = File(baseDirectory, path)
+class FileProjectStreamFactory(private val baseDirectory: File) : ProjectStreamFactory {
+    override fun tryCreate(path: Path): InputStream? {
+        val file = baseDirectory.toPath().resolve(path).toFile()
         if (!file.exists()) {
             LOG.debug("File $path was not found")
             return null

src/main/kotlin/org/jetbrains/dotnet/discovery/JsonAssetsProjectDeserializer.kt

@@ -0,0 +1,85 @@
+package org.jetbrains.dotnet.discovery
+
+import com.google.gson.Gson
+import com.google.gson.JsonSyntaxException
+import org.jetbrains.dotnet.common.toNormalizedUnixString
+import org.jetbrains.dotnet.common.toSystem
+import org.jetbrains.dotnet.discovery.data.*
+import org.jetbrains.dotnet.discovery.data.Reference.Companion.DEFAULT_VERSION
+import org.jetbrains.dotnet.discovery.data.Target
+import org.slf4j.Logger
+import org.slf4j.LoggerFactory
+import java.nio.file.Path
+import java.util.regex.Pattern
+
+class JsonAssetsProjectDeserializer(
+    private val readerFactory: ReaderFactory,
+    private val sourceDiscoverer: NuGetConfigDiscoverer? = null
+) : SolutionDeserializer {
+
+    private val gson: Gson = Gson()
+
+    override fun accept(path: Path): Boolean = PathPattern.matcher(path.toNormalizedUnixString()).find()
+
+    override fun deserialize(path: Path, projectStreamFactory: ProjectStreamFactory): Solution =
+        projectStreamFactory.tryCreate(path)?.use { inputStream ->
+            readerFactory.create(inputStream).use { reader ->
+                val doc = try {
+                    gson.fromJson(reader, JsonAssetsProjectDto::class.java)
+                } catch (e : JsonSyntaxException) {
+                    LOG.debug("$path contains invalid json")
+                    return Solution(emptyList())
+                }
+
+                val targets = doc.targets?.keys?.map { Target(it) } ?: emptyList()
+                val roots : Set<String> = doc.project?.frameworks?.values
+                    ?.flatMap {
+                        it.dependencies?.keys ?: emptySet()
+                    }
+                    ?.toHashSet() ?: emptySet()
+
+                val references = doc.targets?.values
+                    ?.flatMap { it.entries }
+                    ?.map { (id, pkg) ->
+                        val splinteredId = id.split("/")
+                        val name = splinteredId[0]
+                        val version = splinteredId.getOrNull(1) ?: DEFAULT_VERSION
+                        val dependencies = pkg.dependencies?.entries
+                            ?.map { (name, ver) -> Reference(name, ver) } ?: emptyList()
+
+                        val isRoot = roots.contains(name)
+                        Reference(name, version, dependencies, isRoot)
+                     } ?: emptyList()
+
+                val frameworks = doc.project?.frameworks?.keys?.map { Framework(it) } ?: emptyList()
+
+                val fullPathToConfig = doc.project?.restore?.projectPath ?: path.toNormalizedUnixString()
+
+                val configs = doc.project?.restore?.configs
+
+
+                val sources = sourceDiscoverer?.let { discoverer ->
+                    configs?.asSequence()?.flatMap { discoverer.deserializer.deserialize(Path.of(it.toSystem()), projectStreamFactory) }?.toList()
+                    ?: discoverer.discover(path, projectStreamFactory).toList()
+                } ?: emptyList()
+
+                Solution(
+                    listOf(
+                        Project(
+                            fullPathToConfig,
+                            targets = targets,
+                            references = references,
+                            frameworks = frameworks,
+                            sources = sources
+                        )
+                    )
+                )
+            }
+        } ?: Solution(emptyList())
+
+
+    private companion object {
+        private val LOG: Logger = LoggerFactory.getLogger(JsonAssetsProjectDeserializer::class.java.name)
+        private val PathPattern: Pattern = Pattern.compile("^(.+[^\\w\\d]|)project\\.assets\\.json$", Pattern.CASE_INSENSITIVE)
+    }
+}

src/main/kotlin/org/jetbrains/dotnet/discovery/JsonAssetsProjectDto.kt

@@ -0,0 +1,26 @@
+package org.jetbrains.dotnet.discovery
+
+import com.google.gson.annotations.SerializedName
+
+class JsonAssetsProjectDto(
+    @SerializedName("targets") val targets: Map<String, Map<String, PackageDto>>?,
+    @SerializedName("project") val project: ProjectDto?
+)
+
+class PackageDto(
+    @SerializedName("dependencies") val dependencies: Map<String, String>?
+)
+
+class ProjectDto(
+    @SerializedName("restore") val restore : RestoreDto?,
+    @SerializedName("frameworks") val frameworks: Map<String, DependenciesDto>?
+)
+
+class DependenciesDto(
+    @SerializedName("dependencies") val dependencies:  Map<String, Any>?
+)
+
+class RestoreDto(
+    @SerializedName("projectPath") val projectPath : String?,
+    @SerializedName("configFilePaths") val configs : List<String>?
+)