Merge pull request #16 from pettermahlen/redacting-tostring

add support for redacting field values in toString methods

Author: pettermahlen

README.md

@@ -250,7 +250,11 @@ if (message.isLogin()) {
   the `First` class doesn't exist until the annotation processor has run, so the `Second_dataenum` spec
   must reference the `First_dataenum` spec. If `First_dataenum` is in a different package than
   `Second_dataenum`, it must of course be public.
-    
+- If you have sensitive information in a field and don't want the generated `toString` method to 
+  print that information, you can use the `@Redacted` annotation:
+  ```java
+  dataenum_case UserInfo(String name, @Redacted String password);
+  ```    
 
 ## Configuration
 

dataenum-integration-test/src/test/java/com/spotify/dataenum/it/OuterIntegrationTest.java

@@ -24,6 +24,7 @@
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.assertj.core.api.Assertions.assertThatThrownBy;
 
+import com.spotify.dataenum.it.Testing.RedactedValue;
 import com.spotify.dataenum.it.Testing.Three;
 import com.spotify.dataenum.it.Testing.Two;
 import org.junit.Before;
@@ -41,29 +42,35 @@ public void setUp() throws Exception {
   @Test
   public void shouldAllowMapping() throws Exception {
     // should compile and not show warnings
-    String s = t.map(one -> String.valueOf(one.i()), Two::s, Three::s);
+    String s = t.map(one -> String.valueOf(one.i()), Two::s, Three::s, RedactedValue::shouldShow);
 
     // use s to ensure this test class has zero warnings
     assertThat(s).isEqualTo("1");
   }
 
   @Test
   public void shouldAllowConvenientTodoForMap() throws Exception {
-    assertThatThrownBy(() -> t.map(one -> todo(), Two::s, Three::s))
+    assertThatThrownBy(() -> t.map(one -> todo(), Two::s, Three::s, RedactedValue::shouldShow))
         .isInstanceOf(UnsupportedOperationException.class)
         .hasMessageContaining("TODO");
   }
 
   @Test
   public void shouldAllowConvenientTodoForMatch() throws Exception {
-    assertThatThrownBy(() -> t.match(one -> todo(), two -> {}, three -> {}))
+    assertThatThrownBy(() -> t.match(one -> todo(), two -> {}, three -> {}, value -> {}))
         .isInstanceOf(UnsupportedOperationException.class)
         .hasMessageContaining("TODO");
   }
 
   @Test
   public void shouldAllowConvenientIllegalStateForMap() throws Exception {
-    assertThatThrownBy(() -> t.map(one -> illegal("nono: " + one.i()), Two::s, Three::s))
+    assertThatThrownBy(
+            () ->
+                t.map(
+                    one -> illegal("nono: " + one.i()),
+                    Two::s,
+                    Three::s,
+                    RedactedValue::shouldShow))
         .isInstanceOf(IllegalStateException.class)
         .hasMessage("nono: 1");
   }
@@ -73,8 +80,18 @@ public void shouldAllowConvenientIllegalStateForMatch() throws Exception {
     assertThatThrownBy(
             () ->
                 t.match(
-                    one -> illegal("nope, should be: " + (one.i() + 1)), two -> {}, three -> {}))
+                    one -> illegal("nope, should be: " + (one.i() + 1)),
+                    two -> {},
+                    three -> {},
+                    value -> {}))
         .isInstanceOf(IllegalStateException.class)
         .hasMessage("nope, should be: 2");
   }
+
+  @Test
+  public void shouldRedactAnnotatedFieldsInToString() {
+    assertThat(Testing.redactedValue("i want to see this", 866).toString())
+        .contains("i want to see this")
+        .doesNotContain("866");
+  }
 }

dataenum-integration-test/src/test/java/com/spotify/dataenum/it/Testing_dataenum.java

@@ -20,6 +20,7 @@
 package com.spotify.dataenum.it;
 
 import com.spotify.dataenum.DataEnum;
+import com.spotify.dataenum.Redacted;
 import com.spotify.dataenum.dataenum_case;
 
 /** For use in integration-type tests. */
@@ -30,4 +31,6 @@ interface Testing_dataenum {
   dataenum_case Two(String s);
 
   dataenum_case Three(String s);
+
+  dataenum_case RedactedValue(String shouldShow, @Redacted Integer redacted);
 }

dataenum-processor/src/main/java/com/spotify/dataenum/processor/data/Parameter.java

@@ -25,11 +25,13 @@ public class Parameter {
   private final String name;
   private final TypeName type;
   private final boolean nullable;
+  private final boolean redacted;
 
-  public Parameter(String name, TypeName type, boolean nullable) {
+  public Parameter(String name, TypeName type, boolean nullable, boolean redacted) {
     this.name = name;
     this.type = type;
     this.nullable = nullable;
+    this.redacted = redacted;
   }
 
   public String name() {
@@ -43,4 +45,8 @@ public TypeName type() {
   public boolean canBeNull() {
     return nullable;
   }
+
+  public boolean redacted() {
+    return redacted;
+  }
 }

dataenum-processor/src/main/java/com/spotify/dataenum/processor/generator/data/OutputValueFactory.java

@@ -52,7 +52,9 @@ static OutputValue create(Value value, ClassName specOutputClass, Spec spec)
       if (isDataEnumParameter(rawParamType)) {
         TypeName paramOutputType =
             withParametersFromOther(toOutputClass(rawParamType), parameter.type());
-        parameters.add(new Parameter(parameter.name(), paramOutputType, parameter.canBeNull()));
+        parameters.add(
+            new Parameter(
+                parameter.name(), paramOutputType, parameter.canBeNull(), parameter.redacted()));
       } else {
         parameters.add(parameter);
       }

dataenum-processor/src/main/java/com/spotify/dataenum/processor/generator/value/ValueTypeFactory.java

@@ -267,11 +267,17 @@ private static MethodSpec createToString(OutputValue value) {
     for (Parameter parameter : value.parameters()) {
       String fieldName = parameter.name();
 
+      String valueFormat = parameter.redacted() ? "\"***\"" : "$1L";
+
       if (first) {
         first = false;
-        result.addStatement("builder.append(\"$2L{$1N=\").append($1L)", fieldName, value.name());
+        result.addStatement(
+            String.format("builder.append(\"$2L{$1N=\").append(%s)", valueFormat),
+            fieldName,
+            value.name());
       } else {
-        result.addStatement("builder.append(\", $1N=\").append($1L)", fieldName);
+        result.addStatement(
+            String.format("builder.append(\", $1N=\").append(%s)", valueFormat), fieldName);
       }
     }
 

dataenum-processor/src/main/java/com/spotify/dataenum/processor/parser/ValueParser.java

@@ -19,7 +19,9 @@
  */
 package com.spotify.dataenum.processor.parser;
 
+import com.spotify.dataenum.Redacted;
 import com.spotify.dataenum.dataenum_case;
+import com.spotify.dataenum.function.Function;
 import com.spotify.dataenum.processor.data.Parameter;
 import com.spotify.dataenum.processor.data.Value;
 import com.squareup.javapoet.TypeName;
@@ -87,21 +89,38 @@ static Value parse(Element element, ProcessingEnvironment processingEnv) {
       String parameterName = parameterElement.getSimpleName().toString();
       TypeName parameterType = TypeName.get(parameterElement.asType());
 
-      boolean nullable = false;
-      for (AnnotationMirror annotation : parameterElement.getAnnotationMirrors()) {
-        if (isNullableAnnotation(annotation)) {
-          nullable = true;
-          break;
-        }
-      }
+      boolean nullable = isAnnotationPresent(parameterElement, ValueParser::isNullableAnnotation);
+      boolean redacted =
+          isAnnotationPresent(parameterElement, ValueParser.isRedactedAnnotation(processingEnv));
 
-      parameters.add(new Parameter(parameterName, parameterType, nullable));
+      parameters.add(new Parameter(parameterName, parameterType, nullable, redacted));
     }
 
     String valueSimpleName = methodElement.getSimpleName().toString();
     return new Value(valueSimpleName, parameters);
   }
 
+  private static Function<AnnotationMirror, Boolean> isRedactedAnnotation(
+      ProcessingEnvironment processingEnv) {
+    final Types types = processingEnv.getTypeUtils();
+    final Elements elements = processingEnv.getElementUtils();
+
+    return annotationMirror ->
+        types.isSameType(
+            annotationMirror.getAnnotationType(),
+            elements.getTypeElement(Redacted.class.getCanonicalName()).asType());
+  }
+
+  private static boolean isAnnotationPresent(
+      VariableElement parameterElement, Function<AnnotationMirror, Boolean> criterion) {
+    for (AnnotationMirror annotation : parameterElement.getAnnotationMirrors()) {
+      if (criterion.apply(annotation)) {
+        return true;
+      }
+    }
+    return false;
+  }
+
   private static boolean isValueSpecMarker(
       TypeMirror returnType, ProcessingEnvironment processingEnvironment) {
     Types types = processingEnvironment.getTypeUtils();

dataenum/src/main/java/com/spotify/dataenum/Redacted.java

@@ -0,0 +1,33 @@
+/*
+ * -\-\-
+ * DataEnum
+ * --
+ * Copyright (c) 2017 Spotify AB
+ * --
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * -/-/-
+ */
+package com.spotify.dataenum;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * Marks a dataenum field for redaction, meaning that the generated toString() method for that case
+ * will not output the contents of that field.
+ */
+@Retention(RetentionPolicy.SOURCE)
+@Target(ElementType.PARAMETER)
+public @interface Redacted {}