gherkin 4.0.0 → 4.1.0

data/gherkin.berp

@@ -0,0 +1,46 @@
+[
+	Tokens -> #Empty,#Comment,#TagLine,#FeatureLine,#BackgroundLine,#ScenarioLine,#ScenarioOutlineLine,#ExamplesLine,#StepLine,#DocStringSeparator,#TableRow,#Language
+	IgnoredTokens -> #Comment,#Empty
+	ClassName -> Parser
+	Namespace -> Gherkin
+]
+
+GherkinDocument! := Feature?
+Feature! := Feature_Header Background? Scenario_Definition*
+Feature_Header! := #Language? Tags? #FeatureLine Feature_Description
+
+Background! := #BackgroundLine Background_Description Scenario_Step*
+
+// we could avoid defining Scenario_Definition, but that would require regular look-aheads, so worse performance
+Scenario_Definition! := Tags? (Scenario | ScenarioOutline)
+
+Scenario! := #ScenarioLine Scenario_Description Scenario_Step*
+
+ScenarioOutline! := #ScenarioOutlineLine ScenarioOutline_Description ScenarioOutline_Step* Examples_Definition*
+// after the first "Examples" block, interpreting a tag line is ambiguous (tagline of next examples or of next scenario)
+// because of this, we need a lookahead hint, that connects the tag line to the next examples, if there is an examples block ahead
+Examples_Definition! [#Empty|#Comment|#TagLine->#ExamplesLine]:= Tags? Examples
+Examples! := #ExamplesLine Examples_Description Examples_Table?
+Examples_Table! := #TableRow #TableRow*
+
+Scenario_Step := Step
+ScenarioOutline_Step := Step
+
+Step! := #StepLine Step_Arg?
+Step_Arg := (DataTable | DocString)
+
+DataTable! := #TableRow+
+DocString! := #DocStringSeparator #Other* #DocStringSeparator
+
+Tags! := #TagLine+
+
+Feature_Description := Description_Helper
+Background_Description := Description_Helper
+Scenario_Description := Description_Helper
+ScenarioOutline_Description := Description_Helper
+Examples_Description := Description_Helper
+
+// we need to explicitly mention comment, to avoid merging it into the description line's #Other token
+// we also eat the leading empty lines, the tailing lines are not removed by the parser to avoid lookahead, this has to be done by the AST builder
+Description_Helper := #Empty* Description? #Comment*
+Description! := #Other+

data/gherkin.gemspec

@@ -1,22 +1,22 @@
 # encoding: utf-8
 Gem::Specification.new do |s|
   s.name        = 'gherkin'
-  s.version     = '4.0.0'
+  s.version     = '4.1.0'
   s.authors     = ["Gáspár Nagy", "Aslak Hellesøy", "Steve Tooke"]
   s.description = 'Gherkin parser'
   s.summary     = "gherkin-#{s.version}"
   s.email       = 'cukes@googlegroups.com'
-  s.homepage    = "https://github.com/cucumber/gherkin"
+  s.homepage    = "https://github.com/cucumber/gherkin-ruby"
   s.platform    = Gem::Platform::RUBY
   s.license     = "MIT"
   s.required_ruby_version = ">= 1.9.3"
 
-  s.add_development_dependency 'bundler',   '~> 1.7'
-  s.add_development_dependency 'rake',      '~> 10.4'
-  s.add_development_dependency 'rspec',     '~> 3.3'
+  s.add_development_dependency 'bundler'
+  s.add_development_dependency 'rake',      '~> 10.5'
+  s.add_development_dependency 'rspec',     '~> 3.5'
 
   # For coverage reports
-  s.add_development_dependency 'coveralls', '~> 0.8', '< 0.8.8'
+  s.add_development_dependency 'coveralls'
 
   s.rubygems_version = ">= 1.6.1"
   s.files            = `git ls-files`.split("\n").reject {|path| path =~ /\.gitignore$/ }

data/lib/gherkin/gherkin-languages.json

@@ -122,6 +122,93 @@
       "عندما "
     ]
   },
+  "ast": {
+    "and": [
+      "* ",
+      "Y ",
+      "Ya "
+    ],
+    "background": [
+      "Antecedentes"
+    ],
+    "but": [
+      "* ",
+      "Peru "
+    ],
+    "examples": [
+      "Exemplos"
+    ],
+    "feature": [
+      "Carauterística"
+    ],
+    "given": [
+      "* ",
+      "Dáu ",
+      "Dada ",
+      "Daos ",
+      "Daes "
+    ],
+    "name": "Asturian",
+    "native": "asturianu",
+    "scenario": [
+      "Casu"
+    ],
+    "scenarioOutline": [
+      "Esbozu del casu"
+    ],
+    "then": [
+      "* ",
+      "Entós "
+    ],
+    "when": [
+      "* ",
+      "Cuando "
+    ]
+  },
+  "az": {
+    "and": [
+      "* ",
+      "Və ",
+      "Həm "
+    ],
+    "background": [
+      "Keçmiş",
+      "Kontekst"
+    ],
+    "but": [
+      "* ",
+      "Amma ",
+      "Ancaq "
+    ],
+    "examples": [
+      "Nümunələr"
+    ],
+    "feature": [
+      "Özəllik"
+    ],
+    "given": [
+      "* ",
+      "Tutaq ki ",
+      "Verilir "
+    ],
+    "name": "Azerbaijani",
+    "native": "Azərbaycanca",
+    "scenario": [
+      "Ssenari"
+    ],
+    "scenarioOutline": [
+      "Ssenarinin strukturu"
+    ],
+    "then": [
+      "* ",
+      "O halda "
+    ],
+    "when": [
+      "* ",
+      "Əgər ",
+      "Nə vaxt ki "
+    ]
+  },
   "bg": {
     "and": [
       "* ",
@@ -1625,6 +1712,45 @@
       "Menawa "
     ]
   },
+  "ka": {
+    "and": [
+      "* ",
+      "და"
+    ],
+    "background": [
+      "კონტექსტი"
+    ],
+    "but": [
+      "* ",
+      "მაგ­რამ"
+    ],
+    "examples": [
+      "მაგალითები"
+    ],
+    "feature": [
+      "თვისება"
+    ],
+    "given": [
+      "* ",
+      "მოცემული"
+    ],
+    "name": "Georgian",
+    "native": "ქართველი",
+    "scenario": [
+      "სცენარის"
+    ],
+    "scenarioOutline": [
+      "სცენარის ნიმუში"
+    ],
+    "then": [
+      "* ",
+      "მაშინ"
+    ],
+    "when": [
+      "* ",
+      "როდესაც"
+    ]
+  },
   "kn": {
     "and": [
       "* ",
@@ -1830,6 +1956,100 @@
       "Ja "
     ]
   },
+  "mk-Cyrl": {
+    "and": [
+      "* ",
+      "И "
+    ],
+    "background": [
+      "Контекст",
+      "Содржина"
+    ],
+    "but": [
+      "* ",
+      "Но "
+    ],
+    "examples": [
+      "Примери",
+      "Сценарија"
+    ],
+    "feature": [
+      "Функционалност",
+      "Бизнис потреба",
+      "Можност"
+    ],
+    "given": [
+      "* ",
+      "Дадено ",
+      "Дадена "
+    ],
+    "name": "Macedonian",
+    "native": "Македонски",
+    "scenario": [
+      "Сценарио",
+      "На пример"
+    ],
+    "scenarioOutline": [
+      "Преглед на сценарија",
+      "Скица",
+      "Концепт"
+    ],
+    "then": [
+      "* ",
+      "Тогаш "
+    ],
+    "when": [
+      "* ",
+      "Кога "
+    ]
+  },
+  "mk-Latn": {
+    "and": [
+      "* ",
+      "I "
+    ],
+    "background": [
+      "Kontekst",
+      "Sodrzhina"
+    ],
+    "but": [
+      "* ",
+      "No "
+    ],
+    "examples": [
+      "Primeri",
+      "Scenaria"
+    ],
+    "feature": [
+      "Funkcionalnost",
+      "Biznis potreba",
+      "Mozhnost"
+    ],
+    "given": [
+      "* ",
+      "Dadeno ",
+      "Dadena "
+    ],
+    "name": "Macedonian (Latin)",
+    "native": "Makedonski (Latinica)",
+    "scenario": [
+      "Scenario",
+      "Na primer"
+    ],
+    "scenarioOutline": [
+      "Pregled na scenarija",
+      "Skica",
+      "Koncept"
+    ],
+    "then": [
+      "* ",
+      "Togash "
+    ],
+    "when": [
+      "* ",
+      "Koga "
+    ]
+  },
   "mn": {
     "and": [
       "* ",
@@ -1911,7 +2131,8 @@
     ],
     "when": [
       "* ",
-      "Als "
+      "Als ",
+      "Wanneer "
     ]
   },
   "no": {
@@ -2177,7 +2398,8 @@
       "* ",
       "Допустим ",
       "Дано ",
-      "Пусть "
+      "Пусть ",
+      "Если "
     ],
     "name": "Russian",
     "native": "русский",
@@ -2190,11 +2412,11 @@
     "then": [
       "* ",
       "То ",
+      "Затем ",
       "Тогда "
     ],
     "when": [
       "* ",
-      "Если ",
       "Когда "
     ]
   },

data/lib/gherkin/pickles/compiler.rb

@@ -1,7 +1,7 @@
 module Gherkin
   module Pickles
     class Compiler
-      def compile(gherkin_document, path)
+      def compile(gherkin_document)
         pickles = []
 
         return pickles unless gherkin_document[:feature]
@@ -11,11 +11,11 @@ module Gherkin
 
         feature[:children].each do |scenario_definition|
           if(scenario_definition[:type] == :Background)
-            background_steps = pickle_steps(scenario_definition, path)
+            background_steps = pickle_steps(scenario_definition)
           elsif(scenario_definition[:type] == :Scenario)
-            compile_scenario(feature_tags, background_steps, scenario_definition, path, pickles)
+            compile_scenario(feature_tags, background_steps, scenario_definition, feature[:language], pickles)
           else
-            compile_scenario_outline(feature_tags, background_steps, scenario_definition, path, pickles)
+            compile_scenario_outline(feature_tags, background_steps, scenario_definition, feature[:language], pickles)
           end
         end
         return pickles
@@ -23,7 +23,7 @@ module Gherkin
 
     private
 
-      def compile_scenario(feature_tags, background_steps, scenario, path, pickles)
+      def compile_scenario(feature_tags, background_steps, scenario, language, pickles)
         return if scenario[:steps].empty?
 
         steps = [].concat(background_steps)
@@ -31,19 +31,20 @@ module Gherkin
         tags = [].concat(feature_tags).concat(scenario[:tags])
 
         scenario[:steps].each do |step|
-          steps.push(pickle_step(step, path))
+          steps.push(pickle_step(step))
         end
 
         pickle = {
-          tags: pickle_tags(tags, path),
+          tags: pickle_tags(tags),
           name: scenario[:name],
-          locations: [pickle_location(scenario[:location], path)],
+          language: language,
+          locations: [pickle_location(scenario[:location])],
           steps: steps
         }
         pickles.push(pickle)
       end
 
-      def compile_scenario_outline(feature_tags, background_steps, scenario_outline, path, pickles)
+      def compile_scenario_outline(feature_tags, background_steps, scenario_outline, language, pickles)
         return if scenario_outline[:steps].empty?
 
         scenario_outline[:examples].reject { |examples| examples[:tableHeader].nil? }.each do |examples|
@@ -55,13 +56,13 @@ module Gherkin
 
             scenario_outline[:steps].each do |scenario_outline_step|
               step_text = interpolate(scenario_outline_step[:text], variable_cells, value_cells);
-              arguments = create_pickle_arguments(scenario_outline_step[:argument], variable_cells, value_cells, path)
+              arguments = create_pickle_arguments(scenario_outline_step[:argument], variable_cells, value_cells)
               pickle_step = {
                 text: step_text,
                 arguments: arguments,
                 locations: [
-                  pickle_location(values[:location], path),
-                  pickle_step_location(scenario_outline_step, path)
+                  pickle_location(values[:location]),
+                  pickle_step_location(scenario_outline_step)
                 ]
               }
               steps.push(pickle_step)
@@ -69,11 +70,12 @@ module Gherkin
 
             pickle = {
               name: interpolate(scenario_outline[:name], variable_cells, value_cells),
+              language: language,
               steps: steps,
-              tags: pickle_tags(tags, path),
+              tags: pickle_tags(tags),
               locations: [
-                pickle_location(values[:location], path),
-                pickle_location(scenario_outline[:location], path)
+                pickle_location(values[:location]),
+                pickle_location(scenario_outline[:location])
               ]
             }
             pickles.push(pickle);
@@ -82,7 +84,7 @@ module Gherkin
         end
       end
 
-      def create_pickle_arguments(argument, variable_cells, value_cells, path)
+      def create_pickle_arguments(argument, variable_cells, value_cells)
         result = []
         return result if argument.nil?
         if (argument[:type] == :DataTable)
@@ -91,7 +93,7 @@ module Gherkin
               {
                 cells: row[:cells].map do |cell|
                   {
-                    location: pickle_location(cell[:location], path),
+                    location: pickle_location(cell[:location]),
                     value: interpolate(cell[:value], variable_cells, value_cells)
                   }
                 end
@@ -101,7 +103,7 @@ module Gherkin
           result.push(table)
         elsif (argument[:type] == :DocString)
           doc_string = {
-            location: pickle_location(argument[:location], path),
+            location: pickle_location(argument[:location]),
             content: interpolate(argument[:content], variable_cells, value_cells)
           }
           result.push(doc_string)
@@ -119,44 +121,42 @@ module Gherkin
         name
       end
 
-      def pickle_steps(scenario_definition, path)
+      def pickle_steps(scenario_definition)
         scenario_definition[:steps].map do |step|
-          pickle_step(step, path)
+          pickle_step(step)
         end
       end
 
-      def pickle_step(step, path)
+      def pickle_step(step)
         {
           text: step[:text],
-          arguments: create_pickle_arguments(step[:argument], [], [], path),
-          locations: [pickle_step_location(step, path)]
+          arguments: create_pickle_arguments(step[:argument], [], []),
+          locations: [pickle_step_location(step)]
         }
       end
 
-      def pickle_step_location(step, path)
+      def pickle_step_location(step)
         {
-          path: path,
           line: step[:location][:line],
           column: step[:location][:column] + (step[:keyword] ? step[:keyword].length : 0)
         }
       end
 
-      def pickle_location(location, path)
+      def pickle_location(location)
         {
-          path: path,
           line: location[:line],
           column: location[:column]
         }
       end
 
-      def pickle_tags(tags, path)
-        tags.map {|tag| pickle_tag(tag, path)}
+      def pickle_tags(tags)
+        tags.map {|tag| pickle_tag(tag)}
       end
 
-      def pickle_tag(tag, path)
+      def pickle_tag(tag)
         {
           name: tag[:name],
-          location: pickle_location(tag[:location], path)
+          location: pickle_location(tag[:location])
         }
       end
     end