Merge branch 'release-0.3.0'

Author: jamierocks

.github/CODEOWNERS

@@ -0,0 +1,3 @@
+# See https://help.github.com/articles/about-codeowners/
+
+* @jamierocks

.gitignore

@@ -229,6 +229,6 @@ gradle-app.setting
 # End of https://www.gitignore.io/api/java,macos,linux,gradle,windows,intellij+all,intellij+iml
 
 ### Bombe ###
-bombe-*/build/
+bombe*/build/
 
 test-classes/

bombe-asm/build.gradle

@@ -1,5 +1,4 @@
 dependencies {
-    compile project(':bombe-core')
-    compile 'org.ow2.asm:asm-commons:6.2'
-    compile 'com.github.ben-manes.caffeine:caffeine:2.6.2'
+    compile project(':bombe')
+    compile 'org.ow2.asm:asm-commons:7.0'
 }

bombe-asm/src/main/java/me/jamiemansfield/bombe/asm/jar/JarWalker.java

@@ -28,41 +28,38 @@
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-package me.jamiemansfield.bombe.asm.analysis;
+package org.cadixdev.bombe.asm.analysis;
 
-import com.github.benmanes.caffeine.cache.Caffeine;
-import com.github.benmanes.caffeine.cache.LoadingCache;
-import me.jamiemansfield.bombe.analysis.InheritanceProvider;
-import me.jamiemansfield.bombe.asm.jar.SourceSet;
+import org.cadixdev.bombe.analysis.InheritanceProvider;
+import org.cadixdev.bombe.asm.jar.ClassProvider;
+import org.objectweb.asm.ClassReader;
 
 import java.util.Optional;
 
 /**
- * An {@link InheritanceProvider} that obtains all of its information
- * from a given {@link SourceSet}.
+ * An implementation of {@link InheritanceProvider} that retrieves all of
+ * its information from a {@link ClassProvider}.
  *
  * @author Jamie Mansfield
- * @since 0.1.0
+ * @since 0.3.0
  */
-public class SourceSetInheritanceProvider implements InheritanceProvider {
+public class ClassProviderInheritanceProvider implements InheritanceProvider {
 
-    private final LoadingCache<String, ClassInfo> cache;
+    private final ClassProvider provider;
 
-    public SourceSetInheritanceProvider(final SourceSet sources) {
-        this.cache = Caffeine.newBuilder()
-                .build(key -> {
-                    if (sources.has(key)) {
-                        return new ClassNodeClassInfo(sources.get(key));
-                    }
-                    else {
-                        return null;
-                    }
-                });
+    public ClassProviderInheritanceProvider(final ClassProvider provider) {
+        this.provider = provider;
     }
 
     @Override
     public Optional<ClassInfo> provide(final String klass) {
-        return Optional.ofNullable(this.cache.get(klass));
+        final byte[] classBytes = this.provider.get(klass);
+        if (classBytes == null) return Optional.empty();
+
+        final ClassReader reader = new ClassReader(classBytes);
+        final InheritanceClassInfoVisitor classInfoVisitor = new InheritanceClassInfoVisitor();
+        reader.accept(classInfoVisitor, ClassReader.SKIP_CODE | ClassReader.SKIP_DEBUG | ClassReader.SKIP_FRAMES);
+        return Optional.of(classInfoVisitor.create());
     }
 
 }

bombe-asm/src/main/java/me/jamiemansfield/bombe/asm/analysis/SourceSetInheritanceProvider.java renamed to bombe-asm/src/main/java/org/cadixdev/bombe/asm/analysis/ClassProviderInheritanceProvider.java

@@ -0,0 +1,90 @@
+/*
+ * Copyright (c) 2018, Jamie Mansfield <https://jamiemansfield.me/>
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ *  Redistributions of source code must retain the above copyright notice, this
+ *   list of conditions and the following disclaimer.
+ *
+ *  Redistributions in binary form must reproduce the above copyright notice,
+ *   this list of conditions and the following disclaimer in the documentation
+ *   and/or other materials provided with the distribution.
+ *
+ *  Neither the name of the copyright holder nor the names of its
+ *   contributors may be used to endorse or promote products derived from
+ *   this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+package org.cadixdev.bombe.asm.analysis;
+
+import org.cadixdev.bombe.analysis.InheritanceProvider;
+import org.cadixdev.bombe.analysis.InheritanceType;
+import org.cadixdev.bombe.type.signature.FieldSignature;
+import org.cadixdev.bombe.type.signature.MethodSignature;
+import org.objectweb.asm.ClassVisitor;
+import org.objectweb.asm.FieldVisitor;
+import org.objectweb.asm.MethodVisitor;
+import org.objectweb.asm.Opcodes;
+
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+class InheritanceClassInfoVisitor extends ClassVisitor {
+
+    private String name;
+    private boolean isInterface;
+    private String superName;
+    private List<String> interfaces = Collections.emptyList();
+
+    private final Map<FieldSignature, InheritanceType> fields = new HashMap<>();
+    private final Map<String, InheritanceType> fieldsByName = new HashMap<>();
+    private final Map<MethodSignature, InheritanceType> methods = new HashMap<>();
+
+    InheritanceClassInfoVisitor() {
+        super(Opcodes.ASM6);
+    }
+
+    InheritanceProvider.ClassInfo create() {
+        return new InheritanceProvider.ClassInfo.Impl(this.name, this.isInterface, this.superName, this.interfaces,
+                this.fields, this.fieldsByName, this.methods);
+    }
+
+    @Override
+    public void visit(int version, int access, String name, String signature, String superName, String[] interfaces) {
+        this.name = name;
+        this.isInterface = (access & Opcodes.ACC_INTERFACE) != 0;
+        this.superName = superName;
+        this.interfaces = Arrays.asList(interfaces);
+    }
+
+    @Override
+    public FieldVisitor visitField(int access, String name, String descriptor, String signature, Object value) {
+        InheritanceType type = InheritanceType.fromModifiers(access);
+        this.fields.put(FieldSignature.of(name, descriptor), type);
+        this.fieldsByName.put(name, type);
+        return null;
+    }
+
+    @Override
+    public MethodVisitor visitMethod(int access, String name, String descriptor, String signature, String[] exceptions) {
+        this.methods.put(MethodSignature.of(name, descriptor), InheritanceType.fromModifiers(access));
+        return null;
+    }
+
+}

bombe-asm/src/main/java/org/cadixdev/bombe/asm/analysis/InheritanceClassInfoVisitor.java

@@ -28,34 +28,40 @@
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-package me.jamiemansfield.bombe.asm.analysis;
+package org.cadixdev.bombe.asm.jar;
 
-import me.jamiemansfield.bombe.analysis.InheritanceProvider;
-import me.jamiemansfield.bombe.type.signature.FieldSignature;
-import me.jamiemansfield.bombe.type.signature.MethodSignature;
-import org.objectweb.asm.tree.ClassNode;
+import org.cadixdev.bombe.util.ByteStreams;
+
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
 
 /**
- * An implementation of {@link InheritanceProvider.ClassInfo} using data
- * obtained through a {@link ClassNode}.
+ * An implementation of {@link ClassProvider} backed by a {@link ClassLoader}.
  *
  * @author Jamie Mansfield
- * @since 0.1.0
+ * @since 0.3.0
  */
-class ClassNodeClassInfo extends InheritanceProvider.ClassInfo.Impl {
-
-    ClassNodeClassInfo(final ClassNode klass) {
-        super(
-                klass.name,
-                klass.superName
-        );
-        this.interfaces.addAll(klass.interfaces);
-        klass.fields.stream()
-                .map(fieldNode -> FieldSignature.of(fieldNode.name, fieldNode.desc))
-                .forEach(this.fields::add);
-        klass.methods.stream()
-                .map(methodNode -> MethodSignature.of(methodNode.name, methodNode.desc))
-                .forEach(this.methods::add);
+public class ClassLoaderClassProvider implements ClassProvider {
+
+    private final ClassLoader loader;
+
+    public ClassLoaderClassProvider(final ClassLoader loader) {
+        this.loader = loader;
+    }
+
+    @Override
+    public byte[] get(final String klass) {
+        final String internalName = klass + ".class";
+
+        try (final InputStream in = this.loader.getResourceAsStream(internalName)) {
+            final ByteArrayOutputStream baos = new ByteArrayOutputStream();
+            ByteStreams.copy(in, baos);
+            return baos.toByteArray();
+        }
+        catch (final IOException ignored) {
+            return null;
+        }
     }
 
 }