Merge pull request #29 from hotchemi/fix-14

Changed @RuntimePermissions to TypeMirror-based class validation

Author: Shintaro Katafuchi

permissionsdispatcher-processor/src/main/java/permissions/dispatcher/processor/ClassType.java

@@ -10,17 +10,17 @@ enum ClassType {
         this.activity = activity;
     }
 
-    static ClassType getClassType(String className) {
-        if (className.endsWith("Activity")) {
+    public String getActivity() {
+        return activity;
+    }
+
+    static ClassType getClassType(String className, TypeResolver resolver) {
+        if (resolver.isSubTypeOf(className, ConstantsProvider.ACTIVITY)) {
             return ACTIVITY;
-        } else if (className.endsWith("Fragment")) {
+        } else if (resolver.isSubTypeOf(className, ConstantsProvider.V4FRAGMENT)) {
             return FRAGMENT;
         }
         return null;
     }
 
-    public String getActivity() {
-        return activity;
-    }
-
 }

permissionsdispatcher-processor/src/main/java/permissions/dispatcher/processor/ConstantsProvider.java

@@ -6,6 +6,8 @@ interface ConstantsProvider {
 
     ClassName ACTIVITY_COMPAT = ClassName.get("android.support.v4.app", "ActivityCompat");
     ClassName PERMISSION_UTILS = ClassName.get("permissions.dispatcher", "PermissionUtils");
+    String ACTIVITY = "android.app.Activity";
+    String V4FRAGMENT = "android.support.v4.app.Fragment";
     String CLASS_SUFFIX = "PermissionsDispatcher";
     String METHOD_SUFFIX = "WithCheck";
     String REQUEST_CODE_PREFIX = "REQUEST_";

permissionsdispatcher-processor/src/main/java/permissions/dispatcher/processor/PermissionsProcessor.java

@@ -16,6 +16,9 @@
 import javax.annotation.processing.RoundEnvironment;
 import javax.lang.model.SourceVersion;
 import javax.lang.model.element.TypeElement;
+import javax.lang.model.type.TypeMirror;
+import javax.lang.model.util.Elements;
+import javax.lang.model.util.Types;
 import javax.tools.Diagnostic;
 
 import permissions.dispatcher.RuntimePermissions;
@@ -24,7 +27,7 @@
 import static permissions.dispatcher.processor.Utils.getAnnotatedClasses;
 
 @AutoService(Processor.class)
-public class PermissionsProcessor extends AbstractProcessor {
+public class PermissionsProcessor extends AbstractProcessor implements TypeResolver {
 
     private Filer filer;
 
@@ -49,7 +52,7 @@ public synchronized void init(ProcessingEnvironment env) {
 
     @Override
     public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment env) {
-        List<RuntimePermissionsAnnotatedElement> classes = getAnnotatedClasses(env);
+        List<RuntimePermissionsAnnotatedElement> classes = getAnnotatedClasses(env, this);
         for (RuntimePermissionsAnnotatedElement clazz : classes) {
             JavaFile javaFile = createJavaFile(clazz);
             try {
@@ -61,4 +64,12 @@ public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment
         return true;
     }
 
+    @Override
+    public boolean isSubTypeOf(String subTypeClass, String superTypeClass) {
+        Types types = processingEnv.getTypeUtils();
+        Elements elements = processingEnv.getElementUtils();
+        TypeMirror subType = types.getDeclaredType(elements.getTypeElement(subTypeClass));
+        TypeMirror superType = types.getDeclaredType(elements.getTypeElement(superTypeClass));
+        return types.isSubtype(subType, superType);
+    }
 }

permissionsdispatcher-processor/src/main/java/permissions/dispatcher/processor/RuntimePermissionsAnnotatedElement.java

@@ -32,12 +32,12 @@ class RuntimePermissionsAnnotatedElement {
 
     private final List<ExecutableElement> deniedPermissionsMethods;
 
-    RuntimePermissionsAnnotatedElement(TypeElement element) {
+    RuntimePermissionsAnnotatedElement(TypeElement element, TypeResolver resolver) {
         String qualifiedName = element.getQualifiedName().toString();
         packageName = Utils.getPackageName(qualifiedName);
         className = Utils.getClassName(qualifiedName);
-        checkClassName(className);
-        classType = ClassType.getClassType(className);
+        classType = ClassType.getClassType(qualifiedName, resolver);
+        checkClassType(classType);
         needsPermissionMethods = findMethods(element, NeedsPermission.class);
         validateNeedsPermissionMethods();
         needsPermissionsMethods = findMethods(element, NeedsPermissions.class);
@@ -122,8 +122,8 @@ public ExecutableElement getDeniedPermissionFromValue(String value) {
         return findDeniedPermissionFromValue(value, deniedPermissionMethods);
     }
 
-    public ExecutableElement getDeniedPermissionFromValue(String[] value) {
-        return findDeniedPermissionFromValue(value, deniedPermissionsMethods);
+    public ExecutableElement getDeniedPermissionsFromValue(String[] value) {
+        return findDeniedPermissionsFromValue(value, deniedPermissionsMethods);
     }
 
     public ExecutableElement getShowsRationaleFromValue(String value) {

permissionsdispatcher-processor/src/main/java/permissions/dispatcher/processor/TypeResolver.java

@@ -0,0 +1,7 @@
+package permissions.dispatcher.processor;
+
+interface TypeResolver {
+
+    boolean isSubTypeOf(String subTypeClass, String superTypeClass);
+
+}

permissionsdispatcher-processor/src/main/java/permissions/dispatcher/processor/Utils.java

@@ -32,11 +32,11 @@ final class Utils {
     private Utils() {
     }
 
-    static List<RuntimePermissionsAnnotatedElement> getAnnotatedClasses(RoundEnvironment env) {
+    static List<RuntimePermissionsAnnotatedElement> getAnnotatedClasses(RoundEnvironment env, TypeResolver resolver) {
         List<RuntimePermissionsAnnotatedElement> models = new ArrayList<>();
         Set<? extends Element> elements = env.getElementsAnnotatedWith(RuntimePermissions.class);
         for (Element element : elements) {
-            models.add(new RuntimePermissionsAnnotatedElement((TypeElement) element));
+            models.add(new RuntimePermissionsAnnotatedElement((TypeElement) element, resolver));
         }
         return models;
     }
@@ -82,7 +82,7 @@ static ExecutableElement findDeniedPermissionFromValue(String value, List<Execut
         return null;
     }
 
-    static ExecutableElement findDeniedPermissionFromValue(String[] value, List<ExecutableElement> elements) {
+    static ExecutableElement findDeniedPermissionsFromValue(String[] value, List<ExecutableElement> elements) {
         for (ExecutableElement element : elements) {
             DeniedPermissions annotation = element.getAnnotation(DeniedPermissions.class);
             if (deepEquals(value, annotation.value())) {
@@ -111,15 +111,19 @@ static <A extends Annotation> List<String> getValueFromAnnotation(ExecutableElem
     }
 
     static ExecutableElement findDeniedPermissionFromElement(RuntimePermissionsAnnotatedElement element, ExecutableElement method) {
+        Annotation annotation = method.getAnnotation(NeedsPermission.class);
+        if (annotation == null) {
+            annotation = method.getAnnotation(NeedsPermissions.class);
+        }
+        List<String> annotationValues = getValueFromAnnotation(method, annotation.annotationType());
+        if (isEmpty(annotationValues)) {
+            return null;
+        }
         ExecutableElement deniedPermission;
-        // Check presence of @NeedsPermission first
-        List<String> annotationValues = Utils.getValueFromAnnotation(method, NeedsPermission.class);
-        if (!annotationValues.isEmpty()) {
+        if (Objects.equals(annotation.annotationType(), NeedsPermission.class)) {
             deniedPermission = element.getDeniedPermissionFromValue(annotationValues.get(0));
         } else {
-            // Check presence of @NeedsPermissions next
-            annotationValues = Utils.getValueFromAnnotation(method, NeedsPermissions.class);
-            deniedPermission = element.getDeniedPermissionFromValue(annotationValues.toArray(new String[annotationValues.size()]));
+            deniedPermission = element.getDeniedPermissionsFromValue(annotationValues.toArray(new String[annotationValues.size()]));
         }
         return deniedPermission;
     }

permissionsdispatcher-processor/src/main/java/permissions/dispatcher/processor/Validator.java

@@ -28,11 +28,11 @@ static void checkNeedsPermissionsSize(List<ExecutableElement> permission, List<E
         }
     }
 
-    static void checkClassName(String name) {
-        if (name.endsWith("Activity") || name.endsWith("Fragment")) {
+    static void checkClassType(ClassType classType) {
+        if (classType != null) {
             return;
         }
-        throw new WrongClassException("Annotated class must be finished with 'Activity' or 'Fragment'");
+        throw new WrongClassException("Annotated class must be a subclass of 'android.app.Activity' or 'android.support.v4.app.Fragment'");
     }
 
     static void checkDuplicatedValue(List<ExecutableElement> methods, Class<? extends Annotation> clazz) {

permissionsdispatcher-processor/src/test/java/permissions/dispatcher/processor/ClassTypeTest.java

@@ -15,12 +15,4 @@ public void getActivityTest() {
         assertThat(ClassType.FRAGMENT.getActivity()).isEqualTo("target.getActivity()");
     }
 
-    @Test
-    public void getClassTypeTest() {
-        assertThat(ClassType.getClassType("MainActivity")).isEqualTo(ClassType.ACTIVITY);
-        assertThat(ClassType.getClassType("MainFragment")).isEqualTo(ClassType.FRAGMENT);
-        assertThat(ClassType.getClassType("FragmentMain")).isNull();
-        assertThat(ClassType.getClassType("ActivityMain")).isNull();
-    }
-
 }

permissionsdispatcher-processor/src/test/java/permissions/dispatcher/processor/PermissionsProcessorTest.java

@@ -97,6 +97,21 @@ public void twoDeniedPermission() {
         assertJavaSource(actual, expect);
     }
 
+    @Test
+    public void nestedSuperClassActivity() {
+        JavaFileObject actual = forSourceLines(DEFAULT_CLASS, Source.NestedSuperClassActivity.ACTUAL);
+        JavaFileObject expect = forSourceLines(DEFAULT_CLASS + CLASS_SUFFIX, Source.NestedSuperClassActivity.EXPECT);
+        assertJavaSource(actual, expect);
+    }
+
+    @Test
+    public void nestedSuperClassFragment() {
+        String className = "MainFragment";
+        JavaFileObject actual = forSourceLines(className, Source.NestedSuperClassFragment.ACTUAL);
+        JavaFileObject expect = forSourceLines(className + CLASS_SUFFIX, Source.NestedSuperClassFragment.EXPECT);
+        assertJavaSource(actual, expect);
+    }
+
     @Test
     public void deniedPermissionWithoutNeedsPermission() {
         expectedException.expect(RuntimeException.class);
@@ -152,11 +167,11 @@ public void zeroPermission() {
     }
 
     @Test
-    public void wrongClassName() {
+    public void wrongSuperClassType() {
         expectedException.expect(RuntimeException.class);
-        expectedException.expectMessage("Annotated class must be finished with 'Activity' or 'Fragment'");
+        expectedException.expectMessage("Annotated class must be a subclass of 'android.app.Activity' or 'android.support.v4.app.Fragment'");
         String className = "MainUtils";
-        JavaFileObject actual = forSourceLines(className, Source.WrongClassName.ACTUAL);
+        JavaFileObject actual = forSourceLines(className, Source.WrongSuperClassType.ACTUAL);
         JavaFileObject expect = forSourceLines(className + CLASS_SUFFIX, Source.EMPTY);
         assertJavaSource(actual, expect);
     }

permissionsdispatcher-processor/src/test/java/permissions/dispatcher/processor/ValidatorTest.java

@@ -10,7 +10,6 @@
 
 import javax.lang.model.element.ExecutableElement;
 
-import static permissions.dispatcher.processor.Validator.checkClassName;
 import static permissions.dispatcher.processor.Validator.checkNeedsPermissionsSize;
 
 /**
@@ -34,24 +33,4 @@ public void invalidEmpty() {
         checkNeedsPermissionsSize(null, null);
     }
 
-    @Test
-    public void validCheckClassName() {
-        checkClassName("MainActivity");
-        checkClassName("MainFragment");
-    }
-
-    @Test
-    public void invalidCheckClassName1() {
-        expectedException.expect(RuntimeException.class);
-        expectedException.expectMessage("Annotated class must be finished with 'Activity' or 'Fragment'");
-        checkClassName("ActivityMain");
-    }
-
-    @Test
-    public void invalidCheckClassName2() {
-        expectedException.expect(RuntimeException.class);
-        expectedException.expectMessage("Annotated class must be finished with 'Activity' or 'Fragment'");
-        checkClassName("FragmentMain");
-    }
-
 }