cuke_modeler 1.0.4 → 1.1.0

data/testing/rspec/spec/integration/parsing_integration_spec.rb

@@ -8,10 +8,38 @@ describe 'Parsing, Integration' do
 
   describe 'unique behavior' do
 
+    it 'loads the correct dialects based on the version of Gherkin used', :gherkin3 => true, :gherkin4 => true do
+      expect(nodule.dialects).to equal(Gherkin::DIALECTS)
+    end
+
+    it 'loads the correct dialects based on the version of Gherkin used', :gherkin2 => true do
+      expect(nodule.dialects).to equal(Gherkin::I18n::LANGUAGES)
+    end
+
+    it 'can parse text that uses a non-default dialect' do
+      source_text = "# language: en-au
+                     Pretty much:
+
+                       First off:
+                         Y'know foo
+
+                       Awww, look mate:
+                         It's just unbelievable that zip
+                         But at the end of the day I reckon bar
+
+                       Reckon it's like:
+                         Yeah nah zen
+                         Too right baz
+                         You'll wanna:
+                           | param |
+                           | value |"
+
+      expect { nodule.parse_text(source_text) }.to_not raise_error
+    end
 
     it 'raises and error if given something to parse besides a string' do
       expect { nodule.parse_text(5) }.to raise_error(ArgumentError, /Text to parse must be a String but got/)
-      expect { nodule.parse_text('Feature:') }.to_not raise_error
+      expect { nodule.parse_text("#{@feature_keyword}:") }.to_not raise_error
     end
 
     it 'includes the type of object provided when raising an non-string exception' do
@@ -19,7 +47,7 @@ describe 'Parsing, Integration' do
     end
 
     it 'returns an Array' do
-      result = nodule.parse_text('Feature:')
+      result = nodule.parse_text("#{@feature_keyword}:")
       expect(result).to be_a(Array)
     end
 

data/testing/rspec/spec/integration/row_integration_spec.rb

@@ -66,12 +66,11 @@ describe 'Row, Integration' do
     describe 'getting ancestors' do
 
       before(:each) do
-        source = ['Feature: Test feature',
-                  '',
-                  '  Scenario: Test test',
-                  '    * a step:',
-                  '      | a | table |']
-        source = source.join("\n")
+        source = "#{@feature_keyword}: Test feature
+
+                    #{@scenario_keyword}: Test test
+                      #{@step_keyword} a step:
+                        | a | table |"
 
         file_path = "#{@default_file_directory}/row_test_file.feature"
         File.open(file_path, 'w') { |file| file.write(source) }
@@ -114,11 +113,11 @@ describe 'Row, Integration' do
       context 'a row that is part of a scenario' do
 
         before(:each) do
-          source = 'Feature: Test feature
+          source = "#{@feature_keyword}: Test feature
 
-                      Scenario: Test test
-                        * a step:
-                          | a | table |'
+                      #{@scenario_keyword}: Test test
+                        #{@step_keyword} a step:
+                          | a | table |"
 
           file_path = "#{@default_file_directory}/row_test_file.feature"
           File.open(file_path, 'w') { |file| file.write(source) }
@@ -140,11 +139,11 @@ describe 'Row, Integration' do
       context 'a row that is part of a background' do
 
         before(:each) do
-          source = 'Feature: Test feature
+          source = "#{@feature_keyword}: Test feature
 
-                      Background: Test background
-                        * a step:
-                          | a | table |'
+                      #{@background_keyword}: Test background
+                        #{@step_keyword} a step:
+                          | a | table |"
 
           file_path = "#{@default_file_directory}/row_test_file.feature"
           File.open(file_path, 'w') { |file| file.write(source) }
@@ -165,13 +164,13 @@ describe 'Row, Integration' do
       context 'a row that is part of an outline' do
 
         before(:each) do
-          source = 'Feature: Test feature
+          source = "#{@feature_keyword}: Test feature
                       
-                      Scenario Outline: Test outline
-                        * a step
-                      Examples:
+                      #{@outline_keyword}: Test outline
+                        #{@step_keyword} a step
+                      #{@example_keyword}:
                         | param |
-                        | value |'
+                        | value |"
 
           file_path = "#{@default_file_directory}/row_test_file.feature"
           File.open(file_path, 'w') { |file| file.write(source) }
@@ -219,11 +218,11 @@ describe 'Row, Integration' do
         end
 
         it "models the row's source line" do
-          source_text = "Feature: Test feature
+          source_text = "#{@feature_keyword}: Test feature
 
-                           Scenario Outline: Test outline
-                             * a step
-                           Examples:
+                           #{@outline_keyword}: Test outline
+                             #{@step_keyword} a step
+                           #{@example_keyword}:
                              | param |
                              | value |"
           row = CukeModeler::Feature.new(source_text).tests.first.examples.first.rows.first
@@ -239,8 +238,7 @@ describe 'Row, Integration' do
     describe 'row output' do
 
       it 'can be remade from its own output' do
-        source = ['| value1 | value2 |']
-        source = source.join("\n")
+        source = "| value1 | value2 |"
         row = clazz.new(source)
 
         row_output = row.to_s

data/testing/rspec/spec/integration/scenario_integration_spec.rb

@@ -15,19 +15,19 @@ describe 'Scenario, Integration' do
   describe 'unique behavior' do
 
     it 'can be instantiated with the minimum viable Gherkin' do
-      source = 'Scenario:'
+      source = "#{@scenario_keyword}:"
 
       expect { clazz.new(source) }.to_not raise_error
     end
 
     it 'provides a descriptive filename when being parsed from stand alone text' do
-      source = "bad scenario text \n Scenario:\n And a step\n @foo "
+      source = "bad scenario text \n #{@scenario_keyword}:\n And a step\n @foo "
 
       expect { clazz.new(source) }.to raise_error(/'cuke_modeler_stand_alone_scenario\.feature'/)
     end
 
     it 'stores the original data generated by the parsing adapter', :gherkin4 => true do
-      scenario = clazz.new("@tag\nScenario: test scenario\ndescription\n* a step")
+      scenario = clazz.new("@tag\n#{@scenario_keyword}: test scenario\ndescription\n#{@step_keyword} a step")
       data = scenario.parsing_data
 
       expect(data.keys).to match_array([:type, :tags, :location, :keyword, :name, :steps, :description])
@@ -35,7 +35,7 @@ describe 'Scenario, Integration' do
     end
 
     it 'stores the original data generated by the parsing adapter', :gherkin3 => true do
-      scenario = clazz.new("@tag\nScenario: test scenario\ndescription\n* a step")
+      scenario = clazz.new("@tag\n#{@scenario_keyword}: test scenario\ndescription\n#{@step_keyword} a step")
       data = scenario.parsing_data
 
       expect(data.keys).to match_array([:type, :tags, :location, :keyword, :name, :steps, :description])
@@ -43,7 +43,7 @@ describe 'Scenario, Integration' do
     end
 
     it 'stores the original data generated by the parsing adapter', :gherkin2 => true do
-      scenario = clazz.new("@tag\nScenario: test scenario\ndescription\n* a step")
+      scenario = clazz.new("@tag\n#{@scenario_keyword}: test scenario\ndescription\n#{@step_keyword} a step")
       data = scenario.parsing_data
 
       expect(data.keys).to match_array(['keyword', 'name', 'line', 'description', 'id', 'type', 'steps', 'tags'])
@@ -51,10 +51,9 @@ describe 'Scenario, Integration' do
     end
 
     it 'properly sets its child models' do
-      source = ['@a_tag',
-                'Scenario: Test scenario',
-                '  * a step']
-      source = source.join("\n")
+      source = "@a_tag
+                #{@scenario_keyword}: Test scenario
+                  #{@step_keyword} a step"
 
       scenario = clazz.new(source)
       step = scenario.steps.first
@@ -65,7 +64,7 @@ describe 'Scenario, Integration' do
     end
 
     it 'trims whitespace from its source description' do
-      source = ['Scenario:',
+      source = ["#{@scenario_keyword}:",
                 '  ',
                 '        description line 1',
                 '',
@@ -74,11 +73,11 @@ describe 'Scenario, Integration' do
                 '',
                 '',
                 '',
-                '  * a step']
+                "  #{@step_keyword} a step"]
       source = source.join("\n")
 
       scenario = clazz.new(source)
-      description = scenario.description.split("\n")
+      description = scenario.description.split("\n", -1)
 
       expect(description).to eq(['     description line 1',
                                  '',
@@ -90,11 +89,10 @@ describe 'Scenario, Integration' do
     describe 'getting ancestors' do
 
       before(:each) do
-        source = ['Feature: Test feature',
-                  '',
-                  '  Scenario: Test test',
-                  '    * a step']
-        source = source.join("\n")
+        source = "#{@feature_keyword}: Test feature
+
+                    #{@scenario_keyword}: Test test
+                      #{@step_keyword} a step"
 
         file_path = "#{@default_file_directory}/scenario_test_file.feature"
         File.open(file_path, 'w') { |file| file.write(source) }
@@ -128,314 +126,321 @@ describe 'Scenario, Integration' do
         expect(ancestor).to be_nil
       end
 
+    end
 
-      describe 'model population' do
 
-        context 'from source text' do
+    describe 'model population' do
 
-          it "models the scenario's source line" do
-            source_text = "Feature:
+      context 'from source text' do
 
-                           Scenario: foo
-                             * step"
-            scenario = CukeModeler::Feature.new(source_text).tests.first
+        let(:source_text) { "#{@scenario_keyword}:" }
+        let(:scenario) { clazz.new(source_text) }
 
-            expect(scenario.source_line).to eq(3)
-          end
+
+        it "models the scenario's keyword" do
+          expect(scenario.keyword).to eq("#{@scenario_keyword}")
+        end
+
+        it "models the scenario's source line" do
+          source_text = "#{@feature_keyword}:
+
+                           #{@scenario_keyword}: foo
+                             #{@step_keyword} step"
+          scenario = CukeModeler::Feature.new(source_text).tests.first
+
+          expect(scenario.source_line).to eq(3)
+        end
 
 
-          context 'a filled scenario' do
+        context 'a filled scenario' do
 
-            let(:source_text) { '@tag1 @tag2 @tag3
-                                 Scenario: Scenario name
+          let(:source_text) { "@tag1 @tag2 @tag3
+                                 #{@scenario_keyword}: Scenario name
 
                                      Scenario description.
 
                                    Some more.
                                        Even more.
 
-                                 * a step
-                                 * another step' }
-            let(:scenario) { clazz.new(source_text) }
+                                 #{@step_keyword} a step
+                                 #{@step_keyword} another step" }
+          let(:scenario) { clazz.new(source_text) }
 
 
-            it "models the scenario's name" do
-              expect(scenario.name).to eq('Scenario name')
-            end
-
-            it "models the scenario's description" do
-              description = scenario.description.split("\n")
+          it "models the scenario's name" do
+            expect(scenario.name).to eq('Scenario name')
+          end
 
-              expect(description).to eq(['  Scenario description.',
-                                         '',
-                                         'Some more.',
-                                         '    Even more.'])
-            end
+          it "models the scenario's description" do
+            description = scenario.description.split("\n", -1)
 
-            it "models the scenario's steps" do
-              step_names = scenario.steps.collect { |step| step.text }
+            expect(description).to eq(['  Scenario description.',
+                                       '',
+                                       'Some more.',
+                                       '    Even more.'])
+          end
 
-              expect(step_names).to eq(['a step', 'another step'])
-            end
+          it "models the scenario's steps" do
+            step_names = scenario.steps.collect { |step| step.text }
 
-            it "models the scenario's tags" do
-              tag_names = scenario.tags.collect { |tag| tag.name }
+            expect(step_names).to eq(['a step', 'another step'])
+          end
 
-              expect(tag_names).to eq(['@tag1', '@tag2', '@tag3'])
-            end
+          it "models the scenario's tags" do
+            tag_names = scenario.tags.collect { |tag| tag.name }
 
+            expect(tag_names).to eq(['@tag1', '@tag2', '@tag3'])
           end
 
-          context 'an empty scenario' do
+        end
 
-            let(:source_text) { 'Scenario:' }
-            let(:scenario) { clazz.new(source_text) }
+        context 'an empty scenario' do
 
+          let(:source_text) { "#{@scenario_keyword}:" }
+          let(:scenario) { clazz.new(source_text) }
 
-            it "models the scenario's name" do
-              expect(scenario.name).to eq('')
-            end
 
-            it "models the scenario's description" do
-              expect(scenario.description).to eq('')
-            end
+          it "models the scenario's name" do
+            expect(scenario.name).to eq('')
+          end
 
-            it "models the scenario's steps" do
-              expect(scenario.steps).to eq([])
-            end
+          it "models the scenario's description" do
+            expect(scenario.description).to eq('')
+          end
 
-            it "models the scenario's tags" do
-              expect(scenario.tags).to eq([])
-            end
+          it "models the scenario's steps" do
+            expect(scenario.steps).to eq([])
+          end
 
+          it "models the scenario's tags" do
+            expect(scenario.tags).to eq([])
           end
 
         end
 
       end
 
+    end
 
-      describe 'comparison' do
 
-        it 'is equal to a background with the same steps' do
-          source = "Scenario:
-                      * step 1
-                      * step 2"
-          scenario = clazz.new(source)
+    describe 'comparison' do
 
-          source = "Background:
-                      * step 1
-                      * step 2"
-          background_1 = CukeModeler::Background.new(source)
+      it 'is equal to a background with the same steps' do
+        source = "#{@scenario_keyword}:
+                      #{@step_keyword} step 1
+                      #{@step_keyword} step 2"
+        scenario = clazz.new(source)
 
-          source = "Background:
-                      * step 2
-                      * step 1"
-          background_2 = CukeModeler::Background.new(source)
+        source = "#{@background_keyword}:
+                      #{@step_keyword} step 1
+                      #{@step_keyword} step 2"
+        background_1 = CukeModeler::Background.new(source)
 
+        source = "#{@background_keyword}:
+                      #{@step_keyword} step 2
+                      #{@step_keyword} step 1"
+        background_2 = CukeModeler::Background.new(source)
 
-          expect(scenario).to eq(background_1)
-          expect(scenario).to_not eq(background_2)
-        end
 
-        it 'is equal to a scenario with the same steps' do
-          source = "Scenario:
-                      * step 1
-                      * step 2"
-          scenario_1 = clazz.new(source)
+        expect(scenario).to eq(background_1)
+        expect(scenario).to_not eq(background_2)
+      end
 
-          source = "Scenario:
-                      * step 1
-                      * step 2"
-          scenario_2 = clazz.new(source)
+      it 'is equal to a scenario with the same steps' do
+        source = "#{@scenario_keyword}:
+                      #{@step_keyword} step 1
+                      #{@step_keyword} step 2"
+        scenario_1 = clazz.new(source)
 
-          source = "Scenario:
-                      * step 2
-                      * step 1"
-          scenario_3 = clazz.new(source)
+        source = "#{@scenario_keyword}:
+                      #{@step_keyword} step 1
+                      #{@step_keyword} step 2"
+        scenario_2 = clazz.new(source)
 
+        source = "#{@scenario_keyword}:
+                      #{@step_keyword} step 2
+                      #{@step_keyword} step 1"
+        scenario_3 = clazz.new(source)
 
-          expect(scenario_1).to eq(scenario_2)
-          expect(scenario_1).to_not eq(scenario_3)
-        end
 
-        it 'is equal to an outline with the same steps' do
-          source = "Scenario:
-                      * step 1
-                      * step 2"
-          scenario = clazz.new(source)
+        expect(scenario_1).to eq(scenario_2)
+        expect(scenario_1).to_not eq(scenario_3)
+      end
 
-          source = "Scenario Outline:
-                      * step 1
-                      * step 2
-                    Examples:
+      it 'is equal to an outline with the same steps' do
+        source = "#{@scenario_keyword}:
+                      #{@step_keyword} step 1
+                      #{@step_keyword} step 2"
+        scenario = clazz.new(source)
+
+        source = "#{@outline_keyword}:
+                      #{@step_keyword} step 1
+                      #{@step_keyword} step 2
+                    #{@example_keyword}:
                       | param |
                       | value |"
-          outline_1 = CukeModeler::Outline.new(source)
+        outline_1 = CukeModeler::Outline.new(source)
 
-          source = "Scenario Outline:
-                      * step 2
-                      * step 1
-                    Examples:
+        source = "#{@outline_keyword}:
+                      #{@step_keyword} step 2
+                      #{@step_keyword} step 1
+                    #{@example_keyword}:
                       | param |
                       | value |"
-          outline_2 = CukeModeler::Outline.new(source)
+        outline_2 = CukeModeler::Outline.new(source)
 
 
-          expect(scenario).to eq(outline_1)
-          expect(scenario).to_not eq(outline_2)
-        end
+        expect(scenario).to eq(outline_1)
+        expect(scenario).to_not eq(outline_2)
+      end
+
+    end
+
+
+    describe 'scenario output' do
+
+      it 'can be remade from its own output' do
+        source = "@tag1 @tag2 @tag3
+                  #{@scenario_keyword}: A scenario with everything it could have
+
+                  Including a description
+                  and then some.
+
+                    #{@step_keyword} a step
+                      | value |
+                    #{@step_keyword} another step
+                      \"\"\"
+                      some string
+                      \"\"\""
+        scenario = clazz.new(source)
+
+        scenario_output = scenario.to_s
+        remade_scenario_output = clazz.new(scenario_output).to_s
 
+        expect(remade_scenario_output).to eq(scenario_output)
       end
 
 
-      describe 'scenario output' do
+      context 'from source text' do
 
-        it 'can be remade from its own output' do
-          source = ['@tag1 @tag2 @tag3',
-                    'Scenario: A scenario with everything it could have',
-                    '',
-                    'Including a description',
-                    'and then some.',
-                    '',
-                    '  * a step',
-                    '    | value |',
-                    '  * another step',
-                    '    """',
-                    '    some string',
-                    '    """']
+        it 'can output an empty scenario' do
+          source = ["#{@scenario_keyword}:"]
           source = source.join("\n")
           scenario = clazz.new(source)
 
-          scenario_output = scenario.to_s
-          remade_scenario_output = clazz.new(scenario_output).to_s
+          scenario_output = scenario.to_s.split("\n", -1)
 
-          expect(remade_scenario_output).to eq(scenario_output)
+          expect(scenario_output).to eq(["#{@scenario_keyword}:"])
         end
 
+        it 'can output a scenario that has a name' do
+          source = ["#{@scenario_keyword}: test scenario"]
+          source = source.join("\n")
+          scenario = clazz.new(source)
 
-        context 'from source text' do
-
-          it 'can output an empty scenario' do
-            source = ['Scenario:']
-            source = source.join("\n")
-            scenario = clazz.new(source)
-
-            scenario_output = scenario.to_s.split("\n")
+          scenario_output = scenario.to_s.split("\n", -1)
 
-            expect(scenario_output).to eq(['Scenario:'])
-          end
+          expect(scenario_output).to eq(["#{@scenario_keyword}: test scenario"])
+        end
 
-          it 'can output a scenario that has a name' do
-            source = ['Scenario: test scenario']
-            source = source.join("\n")
-            scenario = clazz.new(source)
+        it 'can output a scenario that has a description' do
+          source = ["#{@scenario_keyword}:",
+                    'Some description.',
+                    'Some more description.']
+          source = source.join("\n")
+          scenario = clazz.new(source)
 
-            scenario_output = scenario.to_s.split("\n")
+          scenario_output = scenario.to_s.split("\n", -1)
 
-            expect(scenario_output).to eq(['Scenario: test scenario'])
-          end
+          expect(scenario_output).to eq(["#{@scenario_keyword}:",
+                                         '',
+                                         'Some description.',
+                                         'Some more description.'])
+        end
 
-          it 'can output a scenario that has a description' do
-            source = ['Scenario:',
-                      'Some description.',
-                      'Some more description.']
-            source = source.join("\n")
-            scenario = clazz.new(source)
+        it 'can output a scenario that has steps' do
+          source = ["#{@scenario_keyword}:",
+                    "#{@step_keyword} a step",
+                    '|value|',
+                    "#{@step_keyword} another step",
+                    '"""',
+                    'some string',
+                    '"""']
+          source = source.join("\n")
+          scenario = clazz.new(source)
 
-            scenario_output = scenario.to_s.split("\n")
+          scenario_output = scenario.to_s.split("\n", -1)
 
-            expect(scenario_output).to eq(['Scenario:',
-                                           '',
-                                           'Some description.',
-                                           'Some more description.'])
-          end
+          expect(scenario_output).to eq(["#{@scenario_keyword}:",
+                                         "  #{@step_keyword} a step",
+                                         '    | value |',
+                                         "  #{@step_keyword} another step",
+                                         '    """',
+                                         '    some string',
+                                         '    """'])
+        end
 
-          it 'can output a scenario that has steps' do
-            source = ['Scenario:',
-                      '* a step',
-                      '|value|',
-                      '* another step',
-                      '"""',
-                      'some string',
-                      '"""']
-            source = source.join("\n")
-            scenario = clazz.new(source)
-
-            scenario_output = scenario.to_s.split("\n")
-
-            expect(scenario_output).to eq(['Scenario:',
-                                           '  * a step',
-                                           '    | value |',
-                                           '  * another step',
-                                           '    """',
-                                           '    some string',
-                                           '    """'])
-          end
+        it 'can output a scenario that has tags' do
+          source = ['@tag1 @tag2',
+                    '@tag3',
+                    "#{@scenario_keyword}:"]
+          source = source.join("\n")
+          scenario = clazz.new(source)
 
-          it 'can output a scenario that has tags' do
-            source = ['@tag1 @tag2',
-                      '@tag3',
-                      'Scenario:']
-            source = source.join("\n")
-            scenario = clazz.new(source)
+          scenario_output = scenario.to_s.split("\n", -1)
 
-            scenario_output = scenario.to_s.split("\n")
+          expect(scenario_output).to eq(['@tag1 @tag2 @tag3',
+                                         "#{@scenario_keyword}:"])
+        end
 
-            expect(scenario_output).to eq(['@tag1 @tag2 @tag3',
-                                           'Scenario:'])
-          end
+        it 'can output a scenario that has everything' do
+          source = ['@tag1 @tag2 @tag3',
+                    "#{@scenario_keyword}: A scenario with everything it could have",
+                    'Including a description',
+                    'and then some.',
+                    "#{@step_keyword} a step",
+                    '|value|',
+                    "#{@step_keyword} another step",
+                    '"""',
+                    'some string',
+                    '"""']
+          source = source.join("\n")
+          scenario = clazz.new(source)
 
-          it 'can output a scenario that has everything' do
-            source = ['@tag1 @tag2 @tag3',
-                      'Scenario: A scenario with everything it could have',
-                      'Including a description',
-                      'and then some.',
-                      '* a step',
-                      '|value|',
-                      '* another step',
-                      '"""',
-                      'some string',
-                      '"""']
-            source = source.join("\n")
-            scenario = clazz.new(source)
-
-            scenario_output = scenario.to_s.split("\n")
-
-            expect(scenario_output).to eq(['@tag1 @tag2 @tag3',
-                                           'Scenario: A scenario with everything it could have',
-                                           '',
-                                           'Including a description',
-                                           'and then some.',
-                                           '',
-                                           '  * a step',
-                                           '    | value |',
-                                           '  * another step',
-                                           '    """',
-                                           '    some string',
-                                           '    """'])
-          end
+          scenario_output = scenario.to_s.split("\n", -1)
 
+          expect(scenario_output).to eq(['@tag1 @tag2 @tag3',
+                                         "#{@scenario_keyword}: A scenario with everything it could have",
+                                         '',
+                                         'Including a description',
+                                         'and then some.',
+                                         '',
+                                         "  #{@step_keyword} a step",
+                                         '    | value |',
+                                         "  #{@step_keyword} another step",
+                                         '    """',
+                                         '    some string',
+                                         '    """'])
         end
 
+      end
 
-        context 'from abstract instantiation' do
 
-          let(:scenario) { clazz.new }
+      context 'from abstract instantiation' do
 
+        let(:scenario) { clazz.new }
 
-          it 'can output a scenario that has only tags' do
-            scenario.tags = [CukeModeler::Tag.new]
 
-            expect { scenario.to_s }.to_not raise_error
-          end
+        it 'can output a scenario that has only tags' do
+          scenario.tags = [CukeModeler::Tag.new]
 
-          it 'can output a scenario that has only steps' do
-            scenario.steps = [CukeModeler::Step.new]
+          expect { scenario.to_s }.to_not raise_error
+        end
 
-            expect { scenario.to_s }.to_not raise_error
-          end
+        it 'can output a scenario that has only steps' do
+          scenario.steps = [CukeModeler::Step.new]
 
+          expect { scenario.to_s }.to_not raise_error
         end
 
       end
@@ -445,5 +450,3 @@ describe 'Scenario, Integration' do
   end
 
 end
-
-