merge from upstream

Author: jamesrcounts

src/main/java/org/teachingkidsprogramming/section05recursion/SpiderWeb.java

@@ -19,17 +19,17 @@ public static void main(String[] args)
     //
     //            ------------- Recipe for drawTriangle --#4.2
     //            Do the following 3 times --#3
-    //                Move the tortoise the length of a line --#1.1
+    //                Move the tortoise the current length (of the line) --#1.1
     //                Turn the tortoise 1/3rd of 360 degrees --#2
     //            Repeat
     //            ------------- End of drawTriangle recipe --#4.3
     //
     //            Turn the tortoise 1/6th of 360 degrees to the right --#7
-    //            Increase the length of the line by the current zoom --#8.1
+    //            Increase the current length (of the line) by the current zoom --#8.1
     //        Repeat --#5.2
-    //        ------------- End of weaveOneLayer recipe --#9.2
+    //        ------------- End of weaveOneLayer recipe --#9.3
     //
-    //        Change the zoom so it is multiplied by 1.3 --#11
+    //        Change the current zoom so it is multiplied by 1.3 --#11
     //    Repeat
   }
 }

src/main/java/org/teachingkidsprogramming/section05recursion/TreeQuiz.java

@@ -22,7 +22,7 @@ public void questions1To4()
     //   Question 3 
     //   setNinety (recipe below) 
     //   ------------- Recipe for setNinety 
-    //       set the current turn angle to 90, HINT: Use angles
+    //       set the current turn angle to 90, HINT: Use angles.put(key,value);
     //   ------------- End of setNinety recipe
     //
     //   Question 4 

src/org/teachingextensions/approvals/lite/ApprovalApprover.java

@@ -0,0 +1,11 @@
+package org.teachingextensions.approvals.lite;
+
+public interface ApprovalApprover {
+    boolean approve() throws Exception;
+
+    public void cleanUpAfterSuccess(ApprovalFailureReporter reporter) throws Exception;
+
+    void fail();
+
+    void reportFailure(ApprovalFailureReporter reporter) throws Exception;
+}

src/org/teachingextensions/approvals/lite/ApprovalFailureOverrider.java

@@ -0,0 +1,6 @@
+package org.teachingextensions.approvals.lite;
+
+
+public interface ApprovalFailureOverrider extends ApprovalFailureReporter {
+    public boolean askToChangeReceivedToApproved(String received, String approved) throws Exception;
+}

src/org/teachingextensions/approvals/lite/ApprovalFailureReporter.java

@@ -0,0 +1,5 @@
+package org.teachingextensions.approvals.lite;
+
+public interface ApprovalFailureReporter {
+    public void report(String received, String approved) throws Exception;
+}

src/org/teachingextensions/approvals/lite/ApprovalReporterWithCleanUp.java

@@ -0,0 +1,5 @@
+package org.teachingextensions.approvals.lite;
+
+public interface ApprovalReporterWithCleanUp {
+    public void cleanUp(String received, String approved) throws Exception;
+}

src/org/teachingextensions/approvals/lite/ApprovalWriter.java

@@ -0,0 +1,10 @@
+package org.teachingextensions.approvals.lite;
+
+
+public interface ApprovalWriter {
+    public String writeReceivedFile(String received) throws Exception;
+
+    public String getReceivedFilename(String base);
+
+    public String getApprovalFilename(String base);
+}

src/org/teachingextensions/approvals/lite/Approvals.java

@@ -0,0 +1,104 @@
+package org.teachingextensions.approvals.lite;
+
+import org.teachingextensions.approvals.lite.ReporterFactory.FileTypes;
+import org.teachingextensions.approvals.lite.namer.ApprovalNamer;
+import org.teachingextensions.approvals.lite.namer.JUnitStackTraceNamer;
+import org.teachingextensions.approvals.lite.util.ArrayUtils;
+import org.teachingextensions.approvals.lite.util.ObjectUtils;
+import org.teachingextensions.approvals.lite.util.StringUtils;
+import org.teachingextensions.approvals.lite.util.lambda.Function1;
+import org.teachingextensions.approvals.lite.writers.ApprovalTextWriter;
+import org.teachingextensions.approvals.lite.writers.ComponentApprovalWriter;
+import org.teachingextensions.approvals.lite.writers.ImageApprovalWriter;
+
+import java.awt.*;
+import java.awt.image.BufferedImage;
+import java.util.Arrays;
+
+public class Approvals {
+  public static void verify(String response) throws Exception {
+    verify(new ApprovalTextWriter(response, "txt"), FileTypes.Text);
+  }
+
+  public static <T> void verifyAll(String header, T[] values) {
+    Approvals.verifyAll(header, Arrays.asList(values));
+  }
+
+  public static <T> void verifyAll(String header, Iterable<T> values) {
+    Approvals.verifyAll(header, values, new Function1<T, String>() {
+      @Override
+      public String call(T i) {
+        return i + "";
+      }
+    });
+
+  }
+
+  public static <T> void verifyAll(String header, T[] values,
+                                   Function1<T, String> f1) {
+    verifyAll(header, Arrays.asList(values), f1);
+  }
+
+  public static <T> void verifyAll(String header, Iterable<T> array,
+                                   Function1<T, String> f1) {
+    String text = formatHeader(header) + ArrayUtils.toString(array, f1);
+    verify(new ApprovalTextWriter(text, "txt"), FileTypes.Text);
+  }
+
+  private static String formatHeader(String header) {
+    return StringUtils.isEmpty(header) ? "" : header + "\r\n\r\n\r\n";
+  }
+
+  public static void verifyHtml(String response) throws Exception {
+    verify(new ApprovalTextWriter(response, "html"), FileTypes.Html);
+  }
+
+  public static void verify(Component component) {
+    BufferedImage image = ComponentApprovalWriter.drawComponent(component);
+    Approvals.verify(image);
+  }
+
+  public static void verify(BufferedImage bufferedImage) {
+    verify(new ImageApprovalWriter(bufferedImage), FileTypes.Image);
+  }
+
+  public static void verify(ApprovalWriter writer, ApprovalNamer namer,
+                            ApprovalFailureReporter reporter) {
+    verify(new FileApprover(writer, namer), reporter);
+  }
+
+  public static void verify(ApprovalWriter writer, String fileType) {
+    verify(writer, createApprovalNamer(), ReporterFactory.get(fileType));
+  }
+
+  public static void verify(FileApprover approver,
+                            ApprovalFailureReporter reporter) {
+    try {
+      if (!approver.approve()) {
+        boolean passed = false;
+        if (reporter instanceof ApprovalFailureOverrider) {
+          passed = approver
+              .askToChangeReceivedToApproved((ApprovalFailureOverrider) reporter);
+        }
+        if (!passed) {
+          approver.reportFailure(reporter);
+          approver.fail();
+        } else {
+          approver.cleanUpAfterSuccess(reporter);
+        }
+      } else {
+        approver.cleanUpAfterSuccess(reporter);
+      }
+    } catch (Exception e) {
+      throw ObjectUtils.throwAsError(e);
+    }
+  }
+
+  public static ApprovalNamer createApprovalNamer() {
+    return new JUnitStackTraceNamer();
+  }
+
+  public static void verify(Object o) throws Exception {
+    Approvals.verify(o + "");
+  }
+}

src/org/teachingextensions/approvals/lite/FileApprover.java

@@ -0,0 +1,57 @@
+package org.teachingextensions.approvals.lite;
+
+import junit.framework.TestCase;
+import org.teachingextensions.approvals.lite.namer.ApprovalNamer;
+import org.teachingextensions.approvals.lite.namer.NamerFactory;
+import org.teachingextensions.approvals.lite.util.ObjectUtils;
+import org.teachingextensions.approvals.lite.util.io.FileUtils;
+
+import java.io.File;
+import java.io.IOException;
+
+public class FileApprover implements ApprovalApprover {
+    private File received;
+    private File approved;
+    private final ApprovalWriter writter;
+
+    public FileApprover(ApprovalWriter writter, ApprovalNamer namer) {
+        this.writter = writter;
+        String base = String.format("%s%s%s", namer.getSourceFilePath(), namer.getApprovalName(),
+                NamerFactory.getAndClearAdditionalInformation());
+        received = new File(writter.getReceivedFilename(base));
+        approved = new File(writter.getApprovalFilename(base));
+    }
+
+    public boolean approve() throws Exception {
+        received = new File(writter.writeReceivedFile(received.getAbsolutePath()));
+        return approveTextFile(received, approved);
+    }
+
+    public void cleanUpAfterSuccess(ApprovalFailureReporter reporter) throws Exception {
+        received.delete();
+        if (reporter instanceof ApprovalReporterWithCleanUp) {
+            ((ApprovalReporterWithCleanUp) reporter).cleanUp(received.getAbsolutePath(), approved.getAbsolutePath());
+        }
+    }
+
+    public void reportFailure(ApprovalFailureReporter reporter) throws Exception {
+        reporter.report(received.getAbsolutePath(), approved.getAbsolutePath());
+    }
+
+    public void fail() {
+        TestCase.assertEquals("Failed Approval", approved.getAbsolutePath(), received.getAbsolutePath());
+    }
+
+    public static boolean approveTextFile(File expected, File actual) throws IOException {
+        if (!expected.exists() || !actual.exists()) {
+            return false;
+        }
+        String t1 = FileUtils.readFile(expected);
+        String t2 = FileUtils.readFile(actual);
+        return ObjectUtils.isEqual(t1, t2);
+    }
+
+    public boolean askToChangeReceivedToApproved(ApprovalFailureOverrider reporter) throws Exception {
+        return reporter.askToChangeReceivedToApproved(received.getAbsolutePath(), approved.getAbsolutePath());
+    }
+}

src/org/teachingextensions/approvals/lite/ReporterFactory.java

@@ -0,0 +1,93 @@
+package org.teachingextensions.approvals.lite;
+
+import org.teachingextensions.approvals.lite.reporters.*;
+import org.teachingextensions.approvals.lite.util.ClassUtils;
+
+import java.lang.annotation.Annotation;
+import java.lang.reflect.Method;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+
+public class ReporterFactory {
+    private static HashMap<String, Class<? extends ApprovalFailureReporter>> reporters = new HashMap<>();
+
+    public static class FileTypes {
+        public static final String Text = "txt";
+        public static final String Html = "html";
+        public static final String Excel = "csv";
+        public static final String File = "file";
+        public static final String Image = "png";
+        private static final String Default = "default";
+    }
+
+    static {
+        setupReporters();
+    }
+
+    public static ApprovalFailureReporter get(String string) {
+        ApprovalFailureReporter returned = getFromAnnotation();
+        returned = tryFor(returned, reporters.get(string));
+        returned = tryFor(returned, reporters.get(FileTypes.Default));
+        return returned;
+    }
+
+    public static ApprovalFailureReporter getFromAnnotation() {
+        UseReporter reporter = getAnnotationFromStackTrace(UseReporter.class);
+        return reporter == null ? null : getReporter(reporter);
+    }
+
+    private static ApprovalFailureReporter getReporter(UseReporter reporter) {
+        Class<? extends ApprovalFailureReporter>[] classes = reporter.value();
+        List<ApprovalFailureReporter> reporters = new ArrayList<>();
+        for (Class<? extends ApprovalFailureReporter> clazz : classes) {
+            ApprovalFailureReporter instance = ClassUtils.create(clazz);
+            reporters.add(instance);
+        }
+        return reporters.size() == 1 ? reporters.get(0) : new MultiReporter(reporters);
+    }
+
+    private static <T extends Annotation> T getAnnotationFromStackTrace(Class<T> annotationClass) {
+        StackTraceElement[] trace = Thread.currentThread().getStackTrace();
+        for (StackTraceElement stack : trace) {
+            Method method = null;
+            Class<?> clazz = null;
+            try {
+                String methodName = stack.getMethodName();
+                clazz = Class.forName(stack.getClassName());
+                method = clazz.getMethod(methodName, (Class<?>[]) null);
+            } catch (Exception e) {
+                //ignore
+            }
+            T annotation = null;
+            if (method != null) {
+                annotation = method.getAnnotation(annotationClass);
+            }
+            if (annotation != null) {
+                return annotation;
+            }
+            annotation = clazz != null ? clazz.getAnnotation(annotationClass) : null;
+            if (annotation != null) {
+                return annotation;
+            }
+        }
+        return null;
+    }
+
+    private static ApprovalFailureReporter tryFor(ApprovalFailureReporter returned,
+                                                  Class<? extends ApprovalFailureReporter> trying) {
+        if (returned == null && trying != null) {
+            return ClassUtils.create(trying);
+        }
+        return returned;
+    }
+
+    private static void setupReporters() {
+        reporters.put(FileTypes.Text, DiffReporter.class);
+        reporters.put(FileTypes.Html, DiffReporter.class);
+        reporters.put(FileTypes.Excel, FileLauncherReporter.class);
+        reporters.put(FileTypes.File, FileLauncherReporter.class);
+        reporters.put(FileTypes.Image, ImageReporter.class);
+        reporters.put(FileTypes.Default, QuietReporter.class);
+    }
+}