gherkin 1.0.2 → 1.0.3

data/java/src/gherkin/FixJava.java

@@ -17,14 +17,17 @@ public class FixJava {
         return sb.toString();
     }
 
-    public static String readResourceAsString(String filePath) throws IOException {
-        Reader machine = new InputStreamReader(FixJava.class.getResourceAsStream(filePath));
+    public static String readResource(String filePath) throws IOException {
+        Reader reader = new InputStreamReader(FixJava.class.getResourceAsStream(filePath));
+        return readReader(reader);
+    }
 
+    public static String readReader(Reader reader) throws IOException {
         final char[] buffer = new char[0x10000];
         StringBuilder sb = new StringBuilder();
         int read;
         do {
-            read = machine.read(buffer, 0, buffer.length);
+            read = reader.read(buffer, 0, buffer.length);
             if (read > 0) {
                 sb.append(buffer, 0, read);
             }

data/java/src/gherkin/I18nLexer.java

@@ -0,0 +1,48 @@
+package gherkin;
+
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+public class I18nLexer implements Lexer {
+    private static final Pattern LANGUAGE_PATTERN = Pattern.compile("language\\s*:\\s*(.*)");
+    private final Listener listener;
+    private String i18nLanguage;
+
+    public I18nLexer(Listener listener) {
+        this.listener = listener;
+    }
+
+    /**
+     * @return the i18n language code from the previous scanned source.
+     */
+    public String getI18nLanguage() {
+        return i18nLanguage;
+    }
+
+    public void scan(CharSequence source) {
+        createDelegate(source).scan(source);
+    }
+
+    private Lexer createDelegate(CharSequence source) {
+        i18nLanguage = lang(source);
+        String i18nLanguage = this.i18nLanguage.replaceAll("[\\s-]", "").toLowerCase();
+        String i18nLexerClassName = i18nLanguage.substring(0,1).toUpperCase() + i18nLanguage.substring(1);
+        String qualifiedI18nLexerClassName = "gherkin.lexer." + i18nLexerClassName;
+        try {
+            Class<?> delegateClass = Class.forName(qualifiedI18nLexerClassName);
+            return (Lexer) delegateClass.getConstructor(Listener.class).newInstance(listener);
+        } catch (Exception e) {
+            throw new RuntimeException("Couldn't load lexer class: " + qualifiedI18nLexerClassName, e);
+        }
+    }
+
+    private String lang(CharSequence source) {
+        String lineOne = source.toString().split("\\n")[0];
+        Matcher matcher = LANGUAGE_PATTERN.matcher(lineOne);
+        if(matcher.find()) {
+            return matcher.group(1);
+        } else {
+            return "en";            
+        }
+    }
+}

data/java/src/gherkin/Listener.java

@@ -19,9 +19,11 @@ public interface Listener {
 
     void step(String keyword, String name, int line);
 
-    void table(List<List<String>> rows, int line);
+    void row(List<String> row, int line);
 
     void py_string(String string, int line);
 
+    void eof();
+
     void syntax_error(String state, String event, List<String> legalEvents, int line);
 }

data/java/src/gherkin/Main.java

@@ -0,0 +1,17 @@
+package gherkin;
+
+import gherkin.formatter.PrettyFormatter;
+
+import java.io.FileReader;
+import java.io.IOException;
+
+public class Main {
+    public static void main(String[] args) throws IOException {
+        Parser p = new Parser(new PrettyFormatter(System.out, true));
+        Lexer l = new I18nLexer(p);
+
+        CharSequence input = FixJava.readReader(new FileReader(args[0]));
+        l.scan(input);
+    }
+
+}

data/java/src/gherkin/Parser.java

@@ -79,11 +79,16 @@ public class Parser implements Listener {
             listener.comment(content, line);
     }
 
-    public void table(List<List<String>> rows, int line) {
-        if (event("table", line))
-            listener.table(rows, line);
+    public void row(List<String> row, int line) {
+        if (event("row", line))
+            listener.row(row, line);
     }
 
+    public void eof() {
+        if (event("eof", 1))
+            listener.eof();
+    }
+    
     public void syntax_error(String name, String event, List<String> strings, int line) {
     }
 
@@ -154,6 +159,7 @@ public class Parser implements Listener {
                 }
             }
             Collections.sort(result);
+            result.remove("eof");
             return result;
         }
 

data/java/src/gherkin/formatter/Argument.java

@@ -0,0 +1,39 @@
+package gherkin.formatter;
+
+import java.io.UnsupportedEncodingException;
+import java.util.List;
+
+public class Argument {
+    private final int byteOffset;
+    private final byte[] val;
+
+    public Argument(int byteOffset, String val) throws UnsupportedEncodingException {
+        this.byteOffset = byteOffset;
+        this.val = val.getBytes("UTF-8");
+    }
+
+    public static String format(String string, ArgumentFormat format, List<Argument> arguments) throws UnsupportedEncodingException {
+        return format(string, format, (Argument[]) arguments.toArray(new Argument[arguments.size()]));
+    }
+
+    public static String format(String string, ArgumentFormat format, Argument... arguments) throws UnsupportedEncodingException {
+        byte[] result = string.getBytes("UTF-8");
+        int offset = 0, pastOffset = 0;
+        for (Argument argument : arguments) {
+            if (argument.byteOffset != -1 && argument.byteOffset >= pastOffset) {
+                byte[] replacement = format.formatArgument(argument.val);
+                int delta = replacement.length - argument.val.length;
+                byte[] newResult = new byte[result.length + delta];
+
+                System.arraycopy(result, 0, newResult, 0, argument.byteOffset+offset);
+                System.arraycopy(replacement, 0, newResult, argument.byteOffset+offset, replacement.length);
+                int n = argument.byteOffset + argument.val.length + offset;
+                System.arraycopy(result, n, newResult, argument.byteOffset + replacement.length, result.length - n);
+
+                offset += delta;
+                result = newResult;
+            }
+        }
+        return new String(result, "UTF-8");
+    }
+}

data/java/src/gherkin/formatter/ArgumentFormat.java

@@ -0,0 +1,17 @@
+package gherkin.formatter;
+
+import java.io.UnsupportedEncodingException;
+
+public class ArgumentFormat {
+    private final String prefix;
+    private final String suffix;
+
+    public ArgumentFormat(String prefix, String suffix) {
+        this.prefix = prefix;
+        this.suffix = suffix;
+    }
+
+    public byte[] formatArgument(byte[] argument) throws UnsupportedEncodingException {
+        return (prefix + new String(argument, "UTF-8") + suffix).getBytes("UTF-8");
+    }
+}

data/java/src/gherkin/formatter/Colors.java

@@ -0,0 +1,7 @@
+package gherkin.formatter;
+
+public class Colors {
+    public static String comments(String s, boolean monochrome) {
+        return s;
+    }
+}

data/java/src/gherkin/formatter/Formatter.java

@@ -0,0 +1,15 @@
+package gherkin.formatter;
+
+import gherkin.Listener;
+
+import java.util.List;
+
+/**
+ * This interface extends the Listener interface with extra methods for formatting
+ * Gherkin features during execution.
+ */
+public interface Formatter extends Listener {
+    void scenario(String keyword, String name, int line, String location);
+    void step(String keyword, String name, int line, String status, List<Argument> arguments, String location);
+    void flushTable();
+}

data/java/src/gherkin/formatter/PrettyFormatter.java

@@ -0,0 +1,219 @@
+package gherkin.formatter;
+
+import java.io.OutputStream;
+import java.io.PrintWriter;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.regex.Pattern;
+
+import static gherkin.FixJava.join;
+import static gherkin.formatter.Colors.*;
+
+public class PrettyFormatter implements Formatter {
+    private final PrintWriter out;
+    private final boolean monochrome;
+    private int maxStepLength = 0;
+    private int[] stepLengths;
+    private int stepIndex;
+    private List<List<String>> rows;
+    private List<String> comments;
+    private List<String> tags;
+
+    public PrettyFormatter(OutputStream out, boolean monochrome) {
+        this.out = new PrintWriter(out);
+        this.monochrome = monochrome;
+    }
+
+    public void tag(String name, int line) {
+        if (tags == null) tags = new ArrayList<String>();
+        tags.add('@' + name);
+    }
+
+    public void comment(String content, int line) {
+        if (comments == null) comments = new ArrayList<String>();
+        comments.add(content);
+    }
+
+    public void feature(String keyword, String name, int line) {
+        printCommentsAndTags("");
+        out.println(keyword + ": " + indent(name, "  "));
+        out.flush();
+    }
+
+    public void background(String keyword, String name, int line) {
+        out.println();
+        printCommentsAndTags("  ");
+        out.println("  " + keyword + ": " + name);
+    }
+
+    public void scenario(String keyword, String name, int line) {
+        scenario(keyword, name, line, null);
+    }
+
+    public void scenario(String keyword, String name, int line, String location) {
+        flushTable();
+        out.println();
+        printCommentsAndTags("  ");
+        out.println("  " + keyword + ": " + indent(name, "    ") + indentedScenarioLocation(keyword, name, location));
+        out.flush();
+    }
+
+    public void scenario_outline(String keyword, String name, int line) {
+        flushTable();
+        out.println();
+        printCommentsAndTags("  ");
+        out.println("  " + keyword + ": " + name);
+    }
+
+    public void examples(String keyword, String name, int line) {
+        flushTable();
+        out.println();
+        printCommentsAndTags("    ");
+        out.println("    " + keyword + ": " + name);
+    }
+
+    public void step(String keyword, String name, int line, String status, List<Argument> arguments, String location) {
+        flushTable();
+        out.println("    " + keyword + indent(name, "    ") + indentedStepLocation(location));
+        out.flush();
+    }
+
+    public void flushTable() {
+        if (rows == null) return;
+        int columnCount = rows.get(0).size();
+        int[][] cellLengths = new int[rows.size()][columnCount];
+        int[] maxLengths = new int[columnCount];
+        for (int i = 0; i < rows.size(); i++) {
+            for (int j = 0; j < columnCount; j++) {
+                int length = rows.get(i).get(j).length();
+                cellLengths[i][j] = length;
+                maxLengths[j] = Math.max(maxLengths[j], length);
+            }
+        }
+
+        for (int i = 0; i < rows.size(); i++) {
+            out.write("      | ");
+            for (int j = 0; j < columnCount; j++) {
+                out.write(rows.get(i).get(j));
+                padSpace(maxLengths[j] - cellLengths[i][j]);
+                if (j < columnCount - 1) {
+                    out.write(" | ");
+                } else {
+                    out.write(" |");
+                }
+            }
+            out.println();
+        }
+        out.flush();
+        rows = null;
+    }
+
+    public void step(String keyword, String name, int line) {
+        step(keyword, name, line, null, Collections.<Argument>emptyList(), null);
+    }
+
+    public void row(List<String> row, int line) {
+        if (rows == null) rows = new ArrayList<List<String>>();
+        rows.add(row);
+    }
+
+    public void py_string(String string, int line) {
+        out.println("      \"\"\"");
+        out.print(Pattern.compile("^", Pattern.MULTILINE).matcher(string).replaceAll("      "));
+        out.println("\n      \"\"\"");
+    }
+
+    public void eof() {
+        flushTable();
+        out.flush();
+    }
+
+    public void syntax_error(String state, String event, List<String> legalEvents, int line) {
+        out.println("Syntax error:" + state + ' ' + event);
+    }
+
+    public void steps(List<List<String>> steps) {
+        stepLengths = new int[steps.size()];
+        int i = 0;
+        for (List<String> step : steps) {
+            int stepLength = step.get(0).length() + step.get(1).length();
+            stepLengths[i++] = stepLength;
+            maxStepLength = Math.max(maxStepLength, stepLength);
+        }
+        stepIndex = -1;
+    }
+
+    private void padSpace(int indent, StringBuffer buffer) {
+        for (int i = 0; i < indent; i++) {
+            buffer.append(" ");
+        }
+    }
+
+    private void padSpace(int indent) {
+        for (int i = 0; i < indent; i++) {
+            out.write(" ");
+        }
+    }
+
+    private void printCommentsAndTags(String indent) {
+        printComments(indent);
+        printTags(indent);
+    }
+
+    private boolean printComments(String indent) {
+        if (comments == null) return false;
+        for (String comment : comments) {
+            out.print(indent);
+            out.println(comment);
+        }
+        out.flush();
+        comments = null;
+        return true;
+    }
+
+    private boolean printTags(String indent) {
+        if (tags == null) return false;
+        out.print(indent);
+        out.println(join(tags, " "));
+        out.flush();
+        tags = null;
+        return true;
+    }
+
+    private String indent(String name, String indentation) {
+        String indent = "";
+        StringBuilder sb = new StringBuilder();
+        String[] lines = name.split("\\n");
+        for (int i = 0; i < lines.length; i++) {
+            sb.append(indent).append(lines[i]);
+            if (i < lines.length - 1) {
+                sb.append("\n");
+            }
+            indent = indentation;
+        }
+        return sb.toString();
+    }
+
+    private String indentedScenarioLocation(String keyword, String name, String location) {
+        if (location == null || "".equals(location)) return "";
+        int l = keyword.length() + name.length();
+        maxStepLength = Math.max(maxStepLength, l);
+        int indent = maxStepLength - l;
+
+        StringBuffer buffer = new StringBuffer();
+        padSpace(indent, buffer);
+        buffer.append(" ").append(comments("# " + location, monochrome));
+        return buffer.toString();
+    }
+
+    private String indentedStepLocation(String location) {
+        if (location == null || "".equals(location)) return "";
+        int indent = maxStepLength - stepLengths[stepIndex += 1];
+
+        StringBuffer buffer = new StringBuffer();
+        padSpace(indent, buffer);
+        buffer.append(" ").append(comments("# " + location, monochrome));
+        return buffer.toString();
+    }
+}

data/java/src/gherkin/parser/StateMachineReader.java

@@ -7,6 +7,7 @@ import gherkin.lexer.En;
 
 import java.io.IOException;
 import java.util.List;
+import java.util.ArrayList;
 
 public class StateMachineReader implements Listener {
     private final String machinePath;
@@ -17,9 +18,10 @@ public class StateMachineReader implements Listener {
     }
 
     public List<List<String>> transitionTable() {
+		transitionTable = new ArrayList<List<String>>();
         Lexer lexer = new En(this);
         try {
-            lexer.scan(FixJava.readResourceAsString(machinePath));
+            lexer.scan(FixJava.readResource(machinePath));
         } catch (IOException e) {
             throw new RuntimeException("Fatal error. Couldn't read " + machinePath);
         }
@@ -53,10 +55,13 @@ public class StateMachineReader implements Listener {
     public void py_string(String string, int line) {
     }
 
+    public void eof() {
+    }
+
     public void syntax_error(String name, String event, List<String> strings, int line) {
     }
 
-    public void table(List<List<String>> rows, int line) {
-        transitionTable = rows;
+    public void row(List<String> row, int line) {
+        transitionTable.add(row);
     }
 }