Calculator feature is now passing!

clojure/pom.xml

@@ -12,7 +12,6 @@
     </parent>
 
     <artifactId>clojure</artifactId>
-    <version>0.4.3-SNAPSHOT</version>
     <packaging>jar</packaging>
     <name>Cucumber: Clojure</name>
 

core/pom.xml

@@ -12,7 +12,6 @@
     </parent>
 
     <artifactId>core</artifactId>
-    <version>0.4.3-SNAPSHOT</version>
     <packaging>jar</packaging>
     <name>Cucumber: Core</name>
 

core/src/main/java/cucumber/runtime/CucumberException.java

@@ -1,7 +1,12 @@
 package cucumber.runtime;
 
 public class CucumberException extends RuntimeException {
-    public CucumberException(String message) {
+    /**
+	 * 
+	 */
+	private static final long serialVersionUID = 1393513206771603671L;
+
+	public CucumberException(String message) {
         super(message);
     }
 

core/src/main/java/cucumber/runtime/Runtime.java

@@ -1,21 +1,21 @@
 package cucumber.runtime;
 
-import cucumber.classpath.Classpath;
-import gherkin.GherkinParser;
+import static java.util.Arrays.asList;
 import gherkin.formatter.Argument;
-import gherkin.formatter.model.Feature;
 import gherkin.formatter.model.Step;
 
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.Comparator;
 import java.util.List;
 
-import static java.util.Arrays.asList;
+import cucumber.classpath.Classpath;
+import cucumber.runtime.transformers.Transformer;
 
 public class Runtime {
     private final List<Backend> backends;
     private final List<Step> undefinedSteps = new ArrayList<Step>();
+    private Transformer transformer;
 
     public Runtime(Backend... backends) {
         this.backends = asList(backends);
@@ -45,7 +45,7 @@ private List<StepDefinitionMatch> stepDefinitionMatches(Step step) {
             for (StepDefinition stepDefinition : backend.getStepDefinitions()) {
                 List<Argument> arguments = stepDefinition.matchedArguments(step);
                 if (arguments != null) {
-                    result.add(new StepDefinitionMatch(arguments, stepDefinition, step));
+                    result.add(new StepDefinitionMatch(arguments, stepDefinition, step, getTransformer()));
                 }
             }
         }
@@ -84,4 +84,15 @@ public int compare(Step a, Step b) {
     public World newWorld() {
         return new World(backends, this);
     }
+
+	public Transformer getTransformer() {
+		if (this.transformer == null) {
+			this.transformer = new Transformer();
+		}
+		return this.transformer;
+	}
+
+	public void setTransformer(Transformer transformer) {
+		this.transformer = transformer;
+	}
 }

core/src/main/java/cucumber/runtime/StepDefinitionMatch.java

@@ -6,17 +6,22 @@
 
 import java.lang.reflect.InvocationTargetException;
 import java.util.List;
+import java.util.Locale;
+
+import cucumber.runtime.transformers.Transformer;
 
 import static java.util.Arrays.asList;
 
 public class StepDefinitionMatch extends Match {
     private final StepDefinition stepDefinition;
     private final Step step;
+	private Transformer transformer;
 
-    public StepDefinitionMatch(List<Argument> arguments, StepDefinition stepDefinition, Step step) {
+    public StepDefinitionMatch(List<Argument> arguments, StepDefinition stepDefinition, Step step, Transformer transformer) {
         super(arguments, stepDefinition.getLocation());
         this.stepDefinition = stepDefinition;
         this.step = step;
+        this.transformer = transformer;
     }
 
     public void run(String path) throws Throwable {
@@ -39,13 +44,15 @@ private Object[] getTransformedArgs(Class<?>[] parameterTypes) {
         Object[] result = new Object[getArguments().size()];
         int n = 0;
         for (Argument a : getArguments()) {
-            // TODO: Use the Locale for transformation
-            // TODO: Also use method signature to transform ints...
-            result[n++] = a.getVal();
+            result[n] = this.transformer.transform(a, parameterTypes[n++], getLocale());
         }
         return result;
     }
 
+	private Locale getLocale() {
+		return this.stepDefinition.getLocale();
+	}
+
     private Throwable filterStacktrace(Throwable error, StackTraceElement stepLocation) {
         StackTraceElement[] stackTraceElements = error.getStackTrace();
         if (error.getCause() != null && error.getCause() != error) {

core/src/main/java/cucumber/runtime/World.java

@@ -40,7 +40,7 @@ public void runStep(Step step, String path, Reporter reporter) {
             } finally {
                 long duration = System.nanoTime() - start;
                 String status = e == null ? Result.PASSED : Result.FAILED;
-                Result result = new Result(status, duration, e);
+                Result result = new Result(status, duration, e, null);
                 reporter.result(result);
             }
         } else {

core/src/main/java/cucumber/runtime/transformers/BigDecimalTransformable.java

@@ -0,0 +1,14 @@
+package cucumber.runtime.transformers;
+
+import java.math.BigDecimal;
+
+public class BigDecimalTransformable extends
+		TransformableWithNumberFormat<BigDecimal> {
+
+	@Override
+	protected BigDecimal doTransform(Number number) {
+		// See http://java.sun.com/j2se/6/docs/api/java/math/BigDecimal.html#BigDecimal%28double%29
+		return new BigDecimal(Double.toString(number.doubleValue()));
+	}
+
+}

core/src/main/java/cucumber/runtime/transformers/BigIntegerTransformable.java

@@ -0,0 +1,12 @@
+package cucumber.runtime.transformers;
+
+import java.math.BigInteger;
+
+public class BigIntegerTransformable extends TransformableWithNumberFormat<BigInteger> {
+
+	@Override
+	protected BigInteger doTransform(Number argument) {
+		return BigInteger.valueOf(argument.longValue());
+	}
+
+}

core/src/main/java/cucumber/runtime/transformers/BooleanTransformable.java

@@ -0,0 +1,15 @@
+package cucumber.runtime.transformers;
+
+import java.util.Locale;
+
+public class BooleanTransformable implements Transformable<Boolean> {
+
+	public Boolean transform(String argument, Locale locale) {
+		if ("false".equalsIgnoreCase(argument) || "true".equalsIgnoreCase(argument)) {
+		      return Boolean.parseBoolean(argument);
+		    } else {
+		      throw new TransformationException(String.format(locale, "Could not convert %s to Boolean", argument));
+		    }
+	}
+
+}

core/src/main/java/cucumber/runtime/transformers/ByteTransformable.java

@@ -0,0 +1,10 @@
+package cucumber.runtime.transformers;
+
+public class ByteTransformable extends TransformableWithNumberFormat<Byte> {
+
+	@Override
+	protected Byte doTransform(Number value) {
+		return Byte.valueOf(value.byteValue());
+	}
+
+}

core/src/main/java/cucumber/runtime/transformers/CharacterTransformable.java

@@ -0,0 +1,14 @@
+package cucumber.runtime.transformers;
+
+import java.util.Locale;
+
+public class CharacterTransformable implements Transformable<Character> {
+
+	public Character transform(String argument, Locale locale) {
+		if (argument.length() < 1) {
+			return null;
+		}
+		return Character.valueOf(argument.charAt(0));
+	}
+
+}

core/src/main/java/cucumber/runtime/transformers/DateTransformable.java

@@ -0,0 +1,17 @@
+package cucumber.runtime.transformers;
+
+import java.text.DateFormat;
+import java.text.Format;
+import java.util.Date;
+import java.util.Locale;
+
+public class DateTransformable extends TransformableWithFormat<Date> {
+
+	public Format getFormat(Locale locale) {
+		DateFormat format = DateFormat
+				.getDateInstance(DateFormat.SHORT, locale);
+		format.setLenient(false);
+		return format;
+	}
+
+}

core/src/main/java/cucumber/runtime/transformers/DoubleTransformable.java

@@ -0,0 +1,10 @@
+package cucumber.runtime.transformers;
+
+public class DoubleTransformable extends TransformableWithNumberFormat<Double> {
+
+	@Override
+	protected Double doTransform(Number transform) {
+		return Double.valueOf(transform.doubleValue());
+	}
+
+}

core/src/main/java/cucumber/runtime/transformers/FloatTransformable.java

@@ -0,0 +1,10 @@
+package cucumber.runtime.transformers;
+
+public class FloatTransformable extends TransformableWithNumberFormat<Float> {
+
+	@Override
+	protected Float doTransform(Number argument) {
+		return Float.valueOf(argument.floatValue());
+	}
+
+}

core/src/main/java/cucumber/runtime/transformers/IntegerTransformable.java

@@ -0,0 +1,10 @@
+package cucumber.runtime.transformers;
+
+public class IntegerTransformable extends TransformableWithNumberFormat<Integer> {
+
+	@Override
+	protected Integer doTransform(Number number) {
+		return Integer.valueOf(number.intValue());
+	}
+
+}

core/src/main/java/cucumber/runtime/transformers/LongTransformable.java

@@ -0,0 +1,10 @@
+package cucumber.runtime.transformers;
+
+public class LongTransformable extends TransformableWithNumberFormat<Long> {
+
+	@Override
+	protected Long doTransform(Number argument) {
+		return Long.valueOf(argument.longValue());
+	}
+
+}

core/src/main/java/cucumber/runtime/transformers/ShortTransformable.java

@@ -0,0 +1,10 @@
+package cucumber.runtime.transformers;
+
+public class ShortTransformable extends TransformableWithNumberFormat<Short> {
+
+	@Override
+	protected Short doTransform(Number argument) {
+		return Short.valueOf(argument.shortValue());
+	}
+
+}

core/src/main/java/cucumber/runtime/transformers/StringTransformable.java

@@ -0,0 +1,11 @@
+package cucumber.runtime.transformers;
+
+import java.util.Locale;
+
+public class StringTransformable implements Transformable<String> {
+
+	public String transform(String argument, Locale locale) {
+		return argument;
+	}
+
+}

core/src/main/java/cucumber/runtime/transformers/Transformable.java

@@ -0,0 +1,7 @@
+package cucumber.runtime.transformers;
+
+import java.util.Locale;
+
+public interface Transformable<T> {
+	public T transform(String argument, Locale locale);
+}

core/src/main/java/cucumber/runtime/transformers/TransformableWithFormat.java

@@ -0,0 +1,45 @@
+package cucumber.runtime.transformers;
+
+import java.text.Format;
+import java.text.ParsePosition;
+import java.util.Locale;
+
+public abstract class TransformableWithFormat<T> implements Transformable<T> {
+
+	public T transform(String argument, Locale locale) {
+		return transform(getFormat(locale), argument, locale);
+	}
+
+	/**
+	 * 
+	 * @param locale
+	 *            The locale used to parse
+	 * @return A Format to parse the argument
+	 */
+	public abstract Format getFormat(Locale locale);
+
+	/**
+	 * Parses a value using one of the java.util.text format classes.
+	 * 
+	 * @param format
+	 *            The format to use
+	 * @param argument
+	 *            The object to parse
+	 * @param locale
+	 *            The locale used to parse
+	 * @return The object
+	 * @throws TransformationException
+	 *             Thrown if parsing fails
+	 */
+	@SuppressWarnings("unchecked")
+	protected T transform(final Format format, final String argument,
+			Locale locale) {
+		ParsePosition position = new ParsePosition(0);
+		Object result = format.parseObject(argument, position);
+		if (position.getErrorIndex() != -1) {
+			throw new TransformationException("Can't parse '" + argument
+					+ "' using format " + format);
+		}
+		return (T) result;
+	}
+}

core/src/main/java/cucumber/runtime/transformers/TransformableWithNumberFormat.java

@@ -0,0 +1,22 @@
+package cucumber.runtime.transformers;
+
+import java.text.Format;
+import java.text.NumberFormat;
+import java.util.Locale;
+
+public abstract class TransformableWithNumberFormat<T extends Number> extends
+		TransformableWithFormat<T> {
+
+	@Override
+	public T transform(String argument, Locale locale) {
+		return doTransform(super.transform(argument, locale));
+	}
+
+	@Override
+	public Format getFormat(Locale locale) {
+		return NumberFormat.getNumberInstance(locale);
+	}
+
+	protected abstract T doTransform(Number argument);
+
+}

core/src/main/java/cucumber/runtime/transformers/TransformationException.java

@@ -0,0 +1,21 @@
+package cucumber.runtime.transformers;
+
+public class TransformationException extends RuntimeException {
+
+	/**
+	 * 
+	 */
+	private static final long serialVersionUID = 3893851462286949513L;
+
+	public TransformationException(Throwable t) {
+		super(t);
+	}
+
+	public TransformationException(String message, Throwable t) {
+		super (message, t);
+	}
+
+	public TransformationException(String message) {
+		super (message);
+	}
+}