Updating Gherkin version

.gitignore

@@ -3,3 +3,5 @@ target
 *.iws
 tmp/
 doc/
+/.settings
+/.project

clojure/.gitignore

@@ -0,0 +1,3 @@
+/.classpath
+/.settings
+/.project

clojure/src/main/java/cucumber/runtime/clojure/ClojureBackend.java

@@ -1,17 +1,21 @@
 package cucumber.runtime.clojure;
 
-import clojure.lang.AFunction;
-import clojure.lang.RT;
-import cucumber.classpath.Classpath;
-import cucumber.classpath.Consumer;
-import cucumber.classpath.Input;
-import cucumber.runtime.*;
 import gherkin.formatter.model.Step;
 
 import java.util.ArrayList;
 import java.util.List;
+import java.util.Locale;
 import java.util.regex.Pattern;
 
+import clojure.lang.AFunction;
+import clojure.lang.RT;
+import cucumber.classpath.Classpath;
+import cucumber.classpath.Consumer;
+import cucumber.classpath.Input;
+import cucumber.runtime.Backend;
+import cucumber.runtime.CucumberException;
+import cucumber.runtime.StepDefinition;
+
 public class ClojureBackend implements Backend {
     private final List<StepDefinition> stepDefinitions = new ArrayList<StepDefinition>();
     private String scriptPath;
@@ -67,9 +71,9 @@ private StackTraceElement stepDefLocation(String interpreterClassName, String in
         throw new CucumberException("Couldn't find location for step definition");
     }
 
-    public static void addStepDefinition(Pattern regexp, AFunction body) {
+    public static void addStepDefinition(Pattern regexp, AFunction body, Locale locale) {
         StackTraceElement location = instance.stepDefLocation("clojure.lang.Compiler", "eval");
-        instance.stepDefinitions.add(new ClojureStepDefinition(regexp, body, location));
+        instance.stepDefinitions.add(new ClojureStepDefinition(regexp, body, location, locale));
     }
 
 }

clojure/src/main/java/cucumber/runtime/clojure/ClojureStepDefinition.java

@@ -1,24 +1,27 @@
 package cucumber.runtime.clojure;
 
-import clojure.lang.AFunction;
-import cucumber.runtime.JdkPatternArgumentMatcher;
-import cucumber.runtime.StepDefinition;
-import cuke4duke.internal.Utils;
 import gherkin.formatter.Argument;
 import gherkin.formatter.model.Step;
 
 import java.lang.reflect.InvocationTargetException;
 import java.lang.reflect.Method;
 import java.util.List;
+import java.util.Locale;
 import java.util.regex.Pattern;
 
-public class ClojureStepDefinition implements StepDefinition {
+import clojure.lang.AFunction;
+import cucumber.runtime.AbstractStepDefinition;
+import cucumber.runtime.JdkPatternArgumentMatcher;
+import cuke4duke.internal.Utils;
+
+public class ClojureStepDefinition extends AbstractStepDefinition {
     private final Pattern regexp;
     private final AFunction closure;
     private StackTraceElement location;
 
-    public ClojureStepDefinition(Pattern regexp, AFunction closure, StackTraceElement location) {
-        this.regexp = regexp;
+    public ClojureStepDefinition(Pattern regexp, AFunction closure, StackTraceElement location, Locale locale) {
+        super(locale);
+    	this.regexp = regexp;
         this.closure = closure;
         this.location = location;
     }

core/.gitignore

@@ -0,0 +1,3 @@
+/.classpath
+/.settings
+/.project

core/Rakefile

@@ -1,7 +1,8 @@
+require 'rubygems'
 require 'gherkin/i18n'
 require 'erb'
 
-task :default => ['generate:java', 'generate:groovy']
+task :default => ['generate:java']
 
 namespace :generate do
   desc 'Generate Java code'
@@ -28,13 +29,4 @@ public interface I18n {
     end
   end
 
-  desc 'Generate Groovy code'
-  task :groovy do
-    groovy = ERB.new(IO.read(File.dirname(__FILE__) + '/src/main/code_generator/I18n.groovy.erb'), nil, '-')
-    Gherkin::I18n.all.each do |i18n|
-      File.open(File.dirname(__FILE__) + "/src/main/java/cucumber/runtime/groovy/#{i18n.underscored_iso_code.upcase}.java", 'wb') do |io|
-        io.write(groovy.result(binding))
-      end
-    end
-  end
-end
+ end

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

@@ -0,0 +1,18 @@
+package cucumber.runtime;
+
+import java.util.Locale;
+
+public abstract class AbstractStepDefinition implements StepDefinition {
+	// TODO: Used by StepDefinitionMatch to convert arguments before executions (float etc.)
+	// Maybe pass it to run instead (taking it from the locale of feature instead).
+	// For now StepDefinitions are linked to the Backend with locale agnostic
+	private final Locale locale;
+
+	public AbstractStepDefinition(Locale locale) {
+		this.locale = locale;
+	}
+
+	public Locale getLocale() {
+		return this.locale;
+	}
+}

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/StepDefinition.java

@@ -4,6 +4,7 @@
 import gherkin.formatter.model.Step;
 
 import java.util.List;
+import java.util.Locale;
 
 public interface StepDefinition {
     /**
@@ -40,4 +41,9 @@ public interface StepDefinition {
      * stack traces.
      */
     boolean isDefinedAt(StackTraceElement stackTraceElement); // TODO: redundant with getLocation?
+
+    /**
+     *  @return the locale associated with the step
+     */
+    Locale getLocale();
 }

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/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;
+	}
+
+}