gherkin 1.0.2-java

data/java/src/gherkin/ParseError.java

@@ -0,0 +1,22 @@
+package gherkin;
+
+import java.util.List;
+
+public class ParseError extends RuntimeException {
+    private final String state;
+    private final List<String> expectedEvents;
+
+    public ParseError(String state, String event, List<String> expectedEvents, int line) {
+        super("Parse error on line " + line + ". Found " + event + " when expecting one of: " + FixJava.join(expectedEvents, ", ") + ". (Current state: " + state + ").");
+        this.state = state;
+        this.expectedEvents = expectedEvents;
+    }
+
+    public String state() {
+        return state;
+    }
+
+    public List<String> expectedEvents() {
+        return expectedEvents;
+    }
+}

data/java/src/gherkin/Parser.java

@@ -0,0 +1,185 @@
+package gherkin;
+
+import gherkin.parser.StateMachineReader;
+
+import java.util.*;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+public class Parser implements Listener {
+    List<Machine> machines = new ArrayList<Machine>();
+
+    private Listener listener;
+    private boolean throwOnError;
+
+    public Parser(Listener listener) {
+        this(listener, true);
+    }
+
+    public Parser(Listener listener, boolean throwOnError) {
+        this(listener, throwOnError, "root");
+    }
+
+    public Parser(Listener listener, boolean throwOnError, String machineName) {
+        this.listener = listener;
+        this.throwOnError = throwOnError;
+        pushMachine(machineName);
+    }
+
+    private void pushMachine(String machineName) {
+        machines.add(new Machine(this, machineName));
+    }
+
+    private void popMachine() {
+        machines.remove(machines.size() - 1);
+    }
+
+    public void tag(String name, int line) {
+        if (event("tag", line))
+            listener.tag(name, line);
+    }
+
+    public void py_string(String string, int line) {
+        if (event("py_string", line))
+            listener.py_string(string, line);
+    }
+
+    public void feature(String keyword, String name, int line) {
+        if (event("feature", line))
+            listener.feature(keyword, name, line);
+    }
+
+    public void background(String keyword, String name, int line) {
+        if (event("background", line))
+            listener.background(keyword, name, line);
+    }
+
+    public void scenario(String keyword, String name, int line) {
+        if (event("scenario", line))
+            listener.scenario(keyword, name, line);
+    }
+
+    public void scenario_outline(String keyword, String name, int line) {
+        if (event("scenario_outline", line))
+            listener.scenario_outline(keyword, name, line);
+    }
+
+    public void examples(String keyword, String name, int line) {
+        if (event("examples", line))
+            listener.examples(keyword, name, line);
+    }
+
+    public void step(String keyword, String name, int line) {
+        if (event("step", line))
+            listener.step(keyword, name, line);
+    }
+
+    public void comment(String content, int line) {
+        if (event("comment", line))
+            listener.comment(content, line);
+    }
+
+    public void table(List<List<String>> rows, int line) {
+        if (event("table", line))
+            listener.table(rows, line);
+    }
+
+    public void syntax_error(String name, String event, List<String> strings, int line) {
+    }
+
+    private boolean event(String event, int line) {
+        try {
+            machine().event(event, line);
+            return true;
+        } catch (ParseError e) {
+            if (throwOnError) {
+                throw e;
+            } else {
+                listener.syntax_error(e.state(), event, e.expectedEvents(), line);
+                return false;
+            }
+        }
+    }
+
+    private Machine machine() {
+        return machines.get(machines.size() - 1);
+    }
+
+    private static class Machine {
+        private static final Pattern PUSH = Pattern.compile("push\\((.+)\\)");
+        private static final Map<String, Map<String, Map<String, String>>> TRANSITION_MAPS = new HashMap<String, Map<String, Map<String, String>>>();
+
+        private final Parser parser;
+        private final String name;
+        private String state;
+        private Map<String, Map<String, String>> transitionMap;
+
+        public Machine(Parser parser, String name) {
+            this.parser = parser;
+            this.name = name;
+            this.state = name;
+            this.transitionMap = transitionMap(name);
+        }
+
+        public void event(String event, int line) {
+            Map<String, String> states = transitionMap.get(state);
+            if (states == null) {
+                throw new RuntimeException("Unknown state: " + state + " for machine " + name);
+            }
+            String newState = states.get(event);
+            if (newState == null) {
+                throw new RuntimeException("Unknown transition: " + event + " among " + states + " for machine " + name + " in state " + state);
+            }
+            if ("E".equals(newState)) {
+                throw new ParseError(state, event, expectedEvents(), line);
+            } else {
+                Matcher push = PUSH.matcher(newState);
+                if (push.matches()) {
+                    parser.pushMachine(push.group(1));
+                    parser.event(event, line);
+                } else if ("pop()".equals(newState)) {
+                    parser.popMachine();
+                    parser.event(event, line);
+                } else {
+                    state = newState;
+                }
+            }
+        }
+
+        private List<String> expectedEvents() {
+            List<String> result = new ArrayList<String>();
+            for (String event : transitionMap.get(state).keySet()) {
+                if (!transitionMap.get(state).get(event).equals("E")) {
+                    result.add(event);
+                }
+            }
+            Collections.sort(result);
+            return result;
+        }
+
+        private Map<String, Map<String, String>> transitionMap(String name) {
+            Map<String, Map<String, String>> map = TRANSITION_MAPS.get(name);
+            if(map == null) {
+                map = buildTransitionMap(name);
+                TRANSITION_MAPS.put(name, map);
+            }
+            return map;
+        }
+
+        private Map<String, Map<String, String>> buildTransitionMap(String name) {
+            Map<String, Map<String, String>> result = new HashMap<String, Map<String, String>>();
+            List<List<String>> transitionTable = new StateMachineReader(name).transitionTable();
+            List<String> events = transitionTable.get(0).subList(1, transitionTable.get(0).size());
+            for (List<String> actions : transitionTable.subList(1, transitionTable.size())) {
+                Map<String, String> transitions = new HashMap<String, String>();
+                int col = 1;
+                for (String event : events) {
+                    transitions.put(event, actions.get(col++));
+                }
+                String state = actions.get(0);
+                result.put(state, transitions);
+            }
+            return result;
+        }
+    }
+}

data/java/src/gherkin/lexer/.gitignore

@@ -0,0 +1 @@
+*.java

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

@@ -0,0 +1,62 @@
+package gherkin.parser;
+
+import gherkin.FixJava;
+import gherkin.Lexer;
+import gherkin.Listener;
+import gherkin.lexer.En;
+
+import java.io.IOException;
+import java.util.List;
+
+public class StateMachineReader implements Listener {
+    private final String machinePath;
+    private List<List<String>> transitionTable;
+
+    public StateMachineReader(String name) {
+        machinePath = "/gherkin/parser/" + name + ".txt";
+    }
+
+    public List<List<String>> transitionTable() {
+        Lexer lexer = new En(this);
+        try {
+            lexer.scan(FixJava.readResourceAsString(machinePath));
+        } catch (IOException e) {
+            throw new RuntimeException("Fatal error. Couldn't read " + machinePath);
+        }
+        return transitionTable;
+    }
+
+    public void tag(String name, int line) {
+    }
+
+    public void comment(String content, int line) {
+    }
+
+    public void feature(String keyword, String name, int line) {
+    }
+
+    public void background(String keyword, String name, int line) {
+    }
+
+    public void scenario(String keyword, String name, int line) {
+    }
+
+    public void scenario_outline(String keyword, String name, int line) {
+    }
+
+    public void examples(String keyword, String name, int line) {
+    }
+
+    public void step(String keyword, String name, int line) {
+    }
+
+    public void py_string(String string, int line) {
+    }
+
+    public void syntax_error(String name, String event, List<String> strings, int line) {
+    }
+
+    public void table(List<List<String>> rows, int line) {
+        transitionTable = rows;
+    }
+}

data/lib/.gitignore

@@ -0,0 +1,4 @@
+*.bundle
+*.dll
+*.so
+*.jar

data/lib/gherkin.rb

@@ -0,0 +1,2 @@
+require 'gherkin/i18n_lexer'
+require 'gherkin/parser'

data/lib/gherkin/c_lexer.rb

@@ -0,0 +1,10 @@
+module Gherkin
+  module CLexer
+    def self.[](i18n_language)
+      name = i18n_language.gsub(/[\s-]/, '')
+      require "gherkin_lexer_#{name}"
+      i18n_lexer_class_name = name.capitalize
+      const_get(i18n_lexer_class_name)
+    end
+  end
+end

data/lib/gherkin/cli/main.rb

@@ -0,0 +1,34 @@
+begin
+  require 'trollop'
+rescue LoadError
+  require 'rubygems'
+  require 'trollop'
+end
+require 'gherkin/tools'
+
+module Gherkin
+  module Cli
+    class Main
+      def self.run(args)
+        Trollop::options(args) do
+          banner "Super fast gherkin parser"
+          stop_on Tools::SUB_COMMANDS
+        end
+
+        cmd_name = args.shift
+        begin
+          die("Missing command") if cmd_name.nil?
+          Tools.const_get(cmd_name.capitalize.to_sym).new(args).run
+        rescue NameError
+          die("Unknown command #{cmd_name}")
+        rescue => e
+          Trollop::die(e.message)
+        end
+      end
+
+      def self.die(msg)
+        Trollop::die("#{msg}\nusage: gherkin COMMAND [ARGS]\nAvailable commands: #{Tools::SUB_COMMANDS.join(' ')}")
+      end
+    end
+  end
+end

data/lib/gherkin/core_ext/array.rb

@@ -0,0 +1,5 @@
+class Array
+  def utf8_pack(fmt)
+    (RUBY_VERSION =~ /^1\.9/) ? pack(fmt).force_encoding("UTF-8") : pack(fmt)
+  end
+end

data/lib/gherkin/i18n.rb

@@ -0,0 +1,87 @@
+require 'yaml'
+
+module Gherkin
+  class I18n
+    KEYWORD_KEYS = %w{name native feature background scenario scenario_outline examples given when then and but}
+    LANGUAGES    = YAML.load_file(File.dirname(__FILE__) + '/i18n.yml')
+
+    class << self
+      # Used by code generators for other lexer tools like pygments lexer and textmate bundle
+      def all
+        LANGUAGES.keys.sort.map{|key| get(key)}
+      end
+
+      def get(key)
+        languages[key] ||= new(key)
+      end
+
+      def languages
+        @languages ||= {}
+      end
+    end
+
+    attr_reader :key
+
+    def initialize(key)
+      @key = key
+      @keywords = LANGUAGES[key]
+      raise "Language not supported: #{key.inspect}" if @key.nil?
+      @keywords['grammar_name'] = @keywords['name'].gsub(/\s/, '')
+    end
+
+    def sanitized_key
+      @key.gsub(/[\s-]/, '')
+    end
+
+    def incomplete?
+      KEYWORD_KEYS.detect{|key| @keywords[key].nil?}
+    end
+
+    def feature_keywords
+      keywords('feature')
+    end
+
+    def scenario_keywords
+      keywords('scenario')
+    end
+
+    def scenario_outline_keywords
+      keywords('scenario_outline')
+    end
+
+    def background_keywords
+      keywords('background')
+    end
+
+    def examples_keywords
+      keywords('examples')
+    end
+
+    def but_keywords(space=true)
+      keywords('but', space)
+    end
+
+    def and_keywords(space=true)
+      keywords('and', space)
+    end
+
+    def step_keywords
+      %w{given when then and but}.map{|key| keywords(key, true)}.flatten.uniq
+    end
+
+    def keywords(key, space=false)
+      raise "No #{key} in #{@keywords.inspect}" if @keywords[key].nil?
+      @keywords[key].split('|').map{|kw| space ? keyword_space(kw) : kw}
+    end
+
+    def adverbs
+      %w{given when then and but}.map{|keyword| @keywords[keyword].split('|').map{|w| w.gsub(/[\s<']/, '')}}.flatten
+    end
+
+    private
+
+    def keyword_space(val)
+      (val + ' ').sub(/< $/,'')
+    end
+  end
+end

data/lib/gherkin/i18n.yml

@@ -0,0 +1,535 @@
+# encoding: UTF-8
+# We use the codes here (prefer 2 letters when possible)
+# http://en.wikipedia.org/wiki/List_of_ISO_639-2_codes
+#
+# If you want several aliases for a keyword, just separate them
+# with a | character. Make sure there are no ambiguities in the
+# keywords.
+#
+"en":
+  name: English
+  native: English
+  feature: Feature
+  background: Background
+  scenario: Scenario
+  scenario_outline: Scenario Outline
+  examples: Examples|Scenarios
+  given: "*|Given"
+  when: "*|When"
+  then: "*|Then"
+  and: "*|And"
+  but: "*|But"
+
+# Please help us keeping the languages below uptodate. The parsers for a language
+# that is missing a keyword will expect the English word until the missing word(s)
+# are added.
+#
+# Please keep the grammars in alphabetical order by name from here and down.
+
+"ar":
+  name: Arabic
+  native: العربية
+  feature: خاصية
+  background: الخلفية
+  scenario: سيناريو
+  scenario_outline: سيناريو مخطط
+  examples: امثلة
+  given: "*|بفرض"
+  when: "*|متى|عندما"
+  then: "*|اذاً|ثم"
+  and: "*|و"
+  but: "*|لكن"
+"bg":
+  name: Bulgarian
+  native: български
+  feature: Функционалност
+  background: Предистория
+  scenario: Сценарий
+  scenario_outline: Рамка на сценарий
+  examples: Примери
+  given: "*|Дадено"
+  when: "*|Когато"
+  then: "*|То"
+  and: "*|И"
+  but: "*|Но"
+"cat":
+  name: Catalan
+  native: català
+  background: Rerefons|Antecedents
+  feature: Característica
+  scenario: Escenari
+  scenario_outline: Esquema de l'escenari
+  examples: Exemples
+  given: "*|Donat|Donada"
+  when: "*|Quan"
+  then: "*|Aleshores"
+  and: "*|I"
+  but: "*|Però"
+"cy":
+  name: Welsh
+  native: Cymraeg
+  background: Cefndir
+  feature: Arwedd
+  scenario: Scenario
+  scenario_outline: Scenario Amlinellol
+  examples: Enghreifftiau
+  given: "*|anrhegedig a"
+  when: "*|Pryd"
+  then: "*|Yna"
+  and: "*|A"
+  but: "*|Ond"
+"cs":
+  name: Czech
+  native: Česky
+  feature: Požadavek
+  background: Pozadí|Kontext
+  scenario: Scénář
+  scenario_outline: Náčrt Scénáře|Osnova scénáře
+  examples: Příklady
+  given: "*|Pokud"
+  when: "*|Když"
+  then: "*|Pak"
+  and: "*|A|A také"
+  but: "*|Ale"
+"da":
+  name: Danish
+  native: dansk
+  feature: Egenskab
+  background: Baggrund
+  scenario: Scenarie
+  scenario_outline: Abstrakt Scenario
+  examples: Eksempler
+  given: "*|Givet"
+  when: "*|Når"
+  then: "*|Så"
+  and: "*|Og"
+  but: "*|Men"
+"de":
+  name: German
+  native: Deutsch
+  feature: Funktionalität
+  background: Grundlage
+  scenario: Szenario
+  scenario_outline: Szenariogrundriss
+  examples: Beispiele
+  given: "*|Gegeben sei"
+  when: "*|Wenn"
+  then: "*|Dann"
+  and: "*|Und"
+  but: "*|Aber"
+"en-au":
+  name: Australian
+  native: Australian
+  feature: Crikey
+  background: Background
+  scenario: Mate
+  scenario_outline: Blokes
+  examples: Cobber
+  given: "*|Ya know how"
+  when: "*|When"
+  then: "*|Ya gotta"
+  and: "*|N"
+  but: "*|Cept"
+"en-lol":
+  name: LOLCAT
+  native: LOLCAT
+  feature: OH HAI
+  background: B4
+  scenario: MISHUN
+  scenario_outline: MISHUN SRSLY
+  examples: EXAMPLZ
+  given: "*|I CAN HAZ"
+  when: "*|WEN"
+  then: "*|DEN"
+  and: "*|AN"
+  but: "*|BUT"
+"en-tx":
+  name: Texan
+  native: Texan
+  feature: Feature
+  background: Background
+  scenario: Scenario
+  scenario_outline: All y'all
+  examples: Examples
+  given: "*|Given y'all"
+  when: "*|When y'all"
+  then: "*|Then y'all"
+  and: "*|And y'all"
+  but: "*|But y'all"
+"es":
+  name: Spanish
+  native: español
+  background: Antecedentes
+  feature: Característica
+  scenario: Escenario
+  scenario_outline: Esquema del escenario
+  examples: Ejemplos
+  given: "*|Dado"
+  when: "*|Cuando"
+  then: "*|Entonces"
+  and: "*|Y"
+  but: "*|Pero"
+"et":
+  name: Estonian
+  native: eesti keel
+  feature: Omadus
+  background: Taust
+  scenario: Stsenaarium
+  scenario_outline: Raamstsenaarium
+  examples: Juhtumid
+  given: "*|Eeldades"
+  when: "*|Kui"
+  then: "*|Siis"
+  and: "*|Ja"
+  but: "*|Kuid"
+"fi":
+  name: Finnish
+  native: suomi
+  feature: Ominaisuus
+  background: Tausta
+  scenario: Tapaus
+  scenario_outline: Tapausaihio
+  examples: Tapaukset
+  given: "*|Oletetaan"
+  when: "*|Kun"
+  then: "*|Niin"
+  and: "*|Ja"
+  but: "*|Mutta"
+"fr":
+  name: French
+  native: français
+  feature: Fonctionnalité
+  background: Contexte
+  scenario: Scénario
+  scenario_outline: Plan du scénario|Plan du Scénario
+  examples: Exemples
+  given: "*|Soit|Etant donné"
+  when: "*|Quand|Lorsque|Lorsqu'<"
+  then: "*|Alors"
+  and: "*|Et"
+  but: "*|Mais"
+"he":
+  name: Hebrew
+  native: עברית
+  feature: תכונה
+  background: רקע
+  scenario: תרחיש
+  scenario_outline: תבנית תרחיש
+  examples: דוגמאות
+  given: "*|בהינתן"
+  when: "*|כאשר"
+  then: "*|אז|אזי"
+  and: "*|וגם"
+  but: "*|אבל"
+"hr":
+  name: Croatian
+  native: hrvatski
+  feature: Osobina|Mogućnost|Mogucnost
+  background: Pozadina
+  scenario: Scenarij
+  scenario_outline: Skica|Koncept
+  examples: Primjeri|Scenariji
+  given: "*|Zadan|Zadani|Zadano"
+  when: "*|Kada|Kad"
+  then: "*|Onda"
+  and: "*|I"
+  but: "*|Ali"
+"hu":
+  name: Hungarian
+  native: magyar
+  feature: Jellemző
+  background: Háttér
+  scenario: Forgatókönyv
+  scenario_outline: Forgatókönyv vázlat
+  examples: Példák
+  given: "*|Ha"
+  when: "*|Majd"
+  then: "*|Akkor"
+  and: "*|És"
+  but: "*|De"
+"id":
+  name: Indonesian
+  native: Bahasa Indonesia
+  feature: Fitur
+  background: Dasar
+  scenario: Skenario
+  scenario_outline: Skenario konsep
+  examples: Contoh
+  given: "*|Dengan"
+  when: "*|Ketika"
+  then: "*|Maka"
+  and: "*|Dan"
+  but: "*|Tapi"
+"it":
+  name: Italian
+  native: italiano
+  feature: Funzionalità
+  background: Contesto
+  scenario: Scenario
+  scenario_outline: Schema dello scenario
+  examples: Esempi
+  given: "*|Dato"
+  when: "*|Quando"
+  then: "*|Allora"
+  and: "*|E"
+  but: "*|Ma"
+"ja":
+  name: Japanese
+  native: 日本語
+  feature: フィーチャ|機能
+  background: 背景
+  scenario: シナリオ
+  scenario_outline: シナリオアウトライン|シナリオテンプレート|テンプレ|シナリオテンプレ
+  examples: 例|サンプル
+  given: "*|前提<"
+  when: "*|もし<"
+  then: "*|ならば<"
+  and: "*|かつ<"
+  but: "*|しかし<|但し<|ただし<"
+"ko":
+  name: Korean
+  native: 한국어
+  background: 배경
+  feature: 기능
+  scenario: 시나리오
+  scenario_outline: 시나리오 개요
+  examples: 예
+  given: "*|조건<"
+  when: "*|만일<"
+  then: "*|그러면<"
+  and: "*|그리고<"
+  but: "*|하지만<"
+"lt":
+  name: Lithuanian
+  native: lietuvių kalba
+  feature: Savybė
+  background: Kontekstas
+  scenario: Scenarijus
+  scenario_outline: Scenarijaus šablonas
+  examples: Pavyzdžiai|Scenarijai|Variantai
+  given: "*|Duota"
+  when: "*|Kai"
+  then: "*|Tada"
+  and: "*|Ir"
+  but: "*|Bet"
+"lv":
+  name: Latvian
+  native: latviešu
+  feature: Funkcionalitāte|Fīča
+  background: Konteksts|Situācija
+  scenario: Scenārijs
+  scenario_outline: Scenārijs pēc parauga
+  examples: Piemēri|Paraugs
+  given: "*|Kad"
+  when: "*|Ja"
+  then: "*|Tad"
+  and: "*|Un"
+  but: "*|Bet"
+"nl":
+  name: Dutch
+  native: Nederlands
+  feature: Functionaliteit
+  background: Achtergrond
+  scenario: Scenario
+  scenario_outline: Abstract Scenario
+  examples: Voorbeelden
+  given: "*|Gegeven|Stel"
+  when: "*|Als"
+  then: "*|Dan"
+  and: "*|En"
+  but: "*|Maar"
+"no":
+  name: Norwegian
+  native: norsk
+  feature: Egenskap
+  background: Bakgrunn
+  scenario: Scenario
+  scenario_outline: Abstrakt Scenario
+  examples: Eksempler
+  given: "*|Gitt"
+  when: "*|Når"
+  then: "*|Så"
+  and: "*|Og"
+  but: "*|Men"
+"pl":
+  name: Polish
+  native: polski
+  feature: Właściwość
+  background: Założenia
+  scenario: Scenariusz
+  scenario_outline: Szablon scenariusza
+  examples: Przykłady
+  given: "*|Zakładając"
+  when: "*|Jeżeli"
+  then: "*|Wtedy"
+  and: "*|Oraz"
+  but: "*|Ale"
+"pt":
+  name: Portuguese
+  native: português
+  background: Contexto
+  feature: Funcionalidade
+  scenario: Cenário|Cenario
+  scenario_outline: Esquema do Cenário|Esquema do Cenario
+  examples: Exemplos
+  given: "*|Dado"
+  when: "*|Quando"
+  then: "*|Então|Entao"
+  and: "*|E"
+  but: "*|Mas"
+"ro":
+  name: Romanian
+  native: română
+  background: Conditii
+  feature: Functionalitate
+  scenario: Scenariu
+  scenario_outline: Scenariul de sablon
+  examples: Exemplele
+  given: "*|Daca"
+  when: "*|Cand"
+  then: "*|Atunci"
+  and: "*|Si"
+  but: "*|Dar"
+"ro2":
+  name: Romanian (diacritical)
+  native: română (diacritical)
+  background: Condiţii
+  feature: Funcționalitate
+  scenario: Scenariu
+  scenario_outline: Scenariul de şablon
+  examples: Exemplele
+  given: "*|Dacă"
+  when: "*|Când"
+  then: "*|Atunci"
+  and: "*|Și"
+  but: "*|Dar"
+"ru":
+  name: Russian
+  native: русский
+  feature: Функционал
+  background: Предыстория
+  scenario: Сценарий
+  scenario_outline: Структура сценария
+  examples: Значения
+  given: "*|Допустим"
+  when: "*|Если"
+  then: "*|То"
+  and: "*|И|К тому же"
+  but: "*|Но|А"
+"se":
+  name: Swedish
+  native: Svenska
+  feature: Egenskap
+  background: Bakgrund
+  scenario: Scenario
+  scenario_outline: Abstrakt Scenario
+  examples: Exempel
+  given: "*|Givet"
+  when: "*|När"
+  then: "*|Så"
+  and: "*|Och"
+  but: "*|Men"
+"sk":
+  name: Slovak
+  native: Slovensky
+  feature: Požiadavka
+  background: Pozadie
+  scenario: Scenár
+  scenario_outline: Náčrt Scenáru
+  examples: Príklady
+  given: "*|Pokiaľ"
+  when: "*|Keď"
+  then: "*|Tak"
+  and: "*|A"
+  but: "*|Ale"
+"sr-Latn":
+  name: Serbian_latin
+  native: Srpski_latinica
+  feature: Funkcionalnost|Mogućnost|Mogucnost|Osobina
+  background: Kontekst|Osnova|Pozadina
+  scenario: Scenario|Primer
+  scenario_outline: Struktura scenarija|Skica|Koncept
+  examples: Primeri|Scenariji
+  given: "*|Zadato|Zadate|Zatati"
+  when: "*|Kada|Kad"
+  then: "*|Onda"
+  and: "*|I"
+  but: "*|Ali"
+"sr":
+  name: Serbian
+  native: Српски
+  feature: Функционалност|Могућност|Особина
+  background: Контекст|Основа|Позадина
+  scenario: Сценарио|Пример
+  scenario_outline: Структура сценарија|Скица|Концепт
+  examples: Примери|Сценарији
+  given: "*|Задато|Задате|Задати"
+  when: "*|Када|Кад"
+  then: "*|Онда"
+  and: "*|И"
+  but: "*|Али"
+"tr":
+  name: Turkish
+  native: Türkçe
+  feature: Özellik
+  background: Geçmiş
+  scenario: Senaryo
+  scenario_outline: Senaryo taslağı
+  examples: Örnekler
+  given: "*|Diyelim ki"
+  when: "*|Eğer ki"
+  then: "*|O zaman"
+  and: "*|Ve"
+  but: "*|Fakat|Ama"
+"uz":
+  name: Uzbek
+  native: Узбекча
+  feature: Функционал
+  background: Тарих
+  scenario: Сценарий
+  scenario_outline: Сценарий структураси
+  examples: Мисоллар
+  given: "*|Агар"
+  when: "*|Агар"
+  then: "*|Унда"
+  and: "*|Ва"
+  but: "*|Лекин|Бирок|Аммо"
+"vi":
+  name: Vietnamese
+  native: Tiếng Việt
+  feature: Tính năng
+  background: Bối cảnh
+  scenario: Tình huống|Kịch bản
+  scenario_outline: Khung tình huống|Khung kịch bản
+  examples: Dữ liệu
+  given: "*|Biết|Cho"
+  when: "*|Khi"
+  then: "*|Thì"
+  and: "*|Và"
+  but: "*|Nhưng"
+"zh-CN":
+  name: Chinese simplified
+  native: 简体中文
+  feature: 功能
+  background: 背景
+  scenario: 场景
+  scenario_outline: 场景大纲
+  examples: 例子
+  given: "*|假如<"
+  when: "*|当<"
+  then: "*|那么<"
+  and: "*|而且<"
+  but: "*|但是<"
+"zh-TW":
+  name: Chinese traditional
+  native: 繁體中文
+  feature: 功能
+  background: 背景
+  scenario: 場景|劇本
+  scenario_outline: 場景大綱|劇本大綱
+  examples: 例子
+  given: "*|假設<"
+  when: "*|當<"
+  then: "*|那麼<"
+  and: "*|而且<|並且<"
+  but: "*|但是<"