Always write UTF-8.

Sometimes the system default charset is not UTF-8 and this is sad.
We always want UTF-8, and we want to encourage anyone doing tools
to use UTF-8.

Closes: https://github.com/square/javapoet/pull/474

4 files changed, 35 insertions, 16 deletions

diff --git a/src/main/java/com/squareup/javapoet/JavaFile.java b/src/main/java/com/squareup/javapoet/JavaFile.java
index 973303b..4852f87 100644
--- a/src/main/java/com/squareup/javapoet/JavaFile.java
+++ b/src/main/java/com/squareup/javapoet/JavaFile.java
@@ -39,6 +39,7 @@ import javax.tools.SimpleJavaFileObject;
 
 import static com.squareup.javapoet.Util.checkArgument;
 import static com.squareup.javapoet.Util.checkNotNull;
+import static java.nio.charset.StandardCharsets.UTF_8;
 
 /** A Java file containing a single top level class. */
 public final class JavaFile {
@@ -81,7 +82,7 @@ public final class JavaFile {
     emit(codeWriter);
   }
 
-  /** Writes this to {@code directory} the standard directory structure. */
+  /** Writes this to {@code directory} as UTF-8 using the standard directory structure. */
   public void writeTo(Path directory) throws IOException {
     checkArgument(Files.notExists(directory) || Files.isDirectory(directory),
         "path %s exists but is not a directory.", directory);
@@ -94,12 +95,12 @@ public final class JavaFile {
     }
 
     Path outputPath = outputDirectory.resolve(typeSpec.name + ".java");
-    try (Writer writer = new OutputStreamWriter(Files.newOutputStream(outputPath))) {
+    try (Writer writer = new OutputStreamWriter(Files.newOutputStream(outputPath), UTF_8)) {
       writeTo(writer);
     }
   }
 
-  /** Writes this to {@code directory} the standard directory structure. */
+  /** Writes this to {@code directory} as UTF-8 using the standard directory structure. */
   public void writeTo(File directory) throws IOException {
     writeTo(directory.toPath());
   }
@@ -190,7 +191,7 @@ public final class JavaFile {
         return JavaFile.this.toString();
       }
       @Override public InputStream openInputStream() throws IOException {
-        return new ByteArrayInputStream(getCharContent(true).getBytes());
+        return new ByteArrayInputStream(getCharContent(true).getBytes(UTF_8));
       }
       @Override public long getLastModified() {
         return lastModified;
diff --git a/src/main/java/com/squareup/javapoet/Util.java b/src/main/java/com/squareup/javapoet/Util.java
index 8c3e1bf..15e3909 100644
--- a/src/main/java/com/squareup/javapoet/Util.java
+++ b/src/main/java/com/squareup/javapoet/Util.java
@@ -15,8 +15,6 @@
  */
 package com.squareup.javapoet;
 
-import static java.lang.Character.isISOControl;
-
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collection;
@@ -28,6 +26,8 @@ import java.util.Map;
 import java.util.Set;
 import javax.lang.model.element.Modifier;
 
+import static java.lang.Character.isISOControl;
+
 /**
  * Like Guava, but worse and standalone. This makes it easier to mix JavaPoet with libraries that
  * bring their own version of Guava.
diff --git a/src/test/java/com/squareup/javapoet/FileReadingTest.java b/src/test/java/com/squareup/javapoet/FileReadingTest.java
index 94ba6e8..d10fadd 100644
--- a/src/test/java/com/squareup/javapoet/FileReadingTest.java
+++ b/src/test/java/com/squareup/javapoet/FileReadingTest.java
@@ -15,10 +15,9 @@
  */
 package com.squareup.javapoet;
 
+import com.google.common.io.ByteStreams;
 import java.io.IOException;
 import java.net.URI;
-import java.nio.charset.Charset;
-import java.nio.charset.StandardCharsets;
 import java.util.Collections;
 import java.util.Locale;
 import java.util.concurrent.Callable;
@@ -36,9 +35,9 @@ import org.junit.Test;
 import org.junit.rules.TemporaryFolder;
 import org.junit.runner.RunWith;
 import org.junit.runners.JUnit4;
-import com.google.common.io.ByteStreams;
 
 import static com.google.common.truth.Truth.assertThat;
+import static java.nio.charset.StandardCharsets.UTF_8;
 
 @RunWith(JUnit4.class)
 public class FileReadingTest {
@@ -63,7 +62,7 @@ public class FileReadingTest {
   
   @Test public void javaFileObjectCharacterContent() throws IOException {
     TypeSpec type = TypeSpec.classBuilder("Test")
-        .addJavadoc("Testing, 1, 2, 3!")
+        .addJavadoc("Pi\u00f1ata\u00a1")
         .addMethod(MethodSpec.methodBuilder("fooBar").build())
         .build();
     JavaFile javaFile = JavaFile.builder("foo", type).build();
@@ -74,14 +73,14 @@ public class FileReadingTest {
     assertThat(javaFileObject.getCharContent(false)).isEqualTo(javaFile.toString());
   }
   
-  @Test public void javaFileObjectInputStream() throws IOException {
+  @Test public void javaFileObjectInputStreamIsUtf8() throws IOException {
     JavaFile javaFile = JavaFile.builder("foo", TypeSpec.classBuilder("Test").build())
-        .addFileComment("\u00A9 Copyright character gets you everytime")
+        .addFileComment("Pi\u00f1ata\u00a1")
         .build();
     byte[] bytes = ByteStreams.toByteArray(javaFile.toJavaFileObject().openInputStream());
     
-    // Be explicit with the default charset to assert the implicit behavior in the code
-    assertThat(bytes).isEqualTo(javaFile.toString().getBytes(Charset.defaultCharset()));
+    // JavaPoet always uses UTF-8.
+    assertThat(bytes).isEqualTo(javaFile.toString().getBytes(UTF_8));
   }
   
   @Test public void compileJavaFile() throws Exception {
@@ -100,7 +99,7 @@ public class FileReadingTest {
     JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();
     DiagnosticCollector<JavaFileObject> diagnosticCollector = new DiagnosticCollector<>();
     StandardJavaFileManager fileManager = compiler.getStandardFileManager(diagnosticCollector, 
-        Locale.getDefault(), StandardCharsets.UTF_8);
+        Locale.getDefault(), UTF_8);
     fileManager.setLocation(StandardLocation.CLASS_OUTPUT,
         Collections.singleton(temporaryFolder.newFolder()));
     CompilationTask task = compiler.getTask(null, 
@@ -117,5 +116,4 @@ public class FileReadingTest {
     Callable<?> test = Class.forName("foo.Test", true, loader).asSubclass(Callable.class).newInstance();
     assertThat(Callable.class.getMethod("call").invoke(test)).isEqualTo(value);
   }
-
 }
diff --git a/src/test/java/com/squareup/javapoet/FileWritingTest.java b/src/test/java/com/squareup/javapoet/FileWritingTest.java
index dc37561..f817ddb 100644
--- a/src/test/java/com/squareup/javapoet/FileWritingTest.java
+++ b/src/test/java/com/squareup/javapoet/FileWritingTest.java
@@ -33,6 +33,7 @@ import org.junit.runners.JUnit4;
 import org.mockito.Mockito;
 
 import static com.google.common.truth.Truth.assertThat;
+import static java.nio.charset.StandardCharsets.UTF_8;
 import static org.junit.Assert.fail;
 
 @RunWith(JUnit4.class)
@@ -196,4 +197,23 @@ public final class FileWritingTest {
         + "\t}\n"
         + "}\n");
   }
+
+  /**
+   * This test confirms that JavaPoet ignores the host charset and always uses UTF-8. The host
+   * charset is customized with {@code -Dfile.encoding=ISO-8859-1}.
+   */
+  @Test public void fileIsUtf8() throws IOException {
+    JavaFile javaFile = JavaFile.builder("foo", TypeSpec.classBuilder("Taco").build())
+        .addFileComment("Pi\u00f1ata\u00a1")
+        .build();
+    javaFile.writeTo(fsRoot);
+
+    Path fooPath = fsRoot.resolve(fs.getPath("foo", "Taco.java"));
+    assertThat(new String(Files.readAllBytes(fooPath), UTF_8)).isEqualTo(""
+        + "// Pi\u00f1ata\u00a1\n"
+        + "package foo;\n"
+        + "\n"
+        + "class Taco {\n"
+        + "}\n");
+  }
 }