cuke_modeler 2.0.0 → 2.1.0

data/lib/cuke_modeler/adapters/gherkin_8_adapter.rb

@@ -0,0 +1,12 @@
+require_relative 'gherkin_7_adapter'
+
+module CukeModeler
+
+  # NOT A PART OF THE PUBLIC API
+  # An adapter that can convert the output of version 8.x of the *gherkin* gem into input that is consumable by this gem.
+
+  class Gherkin8Adapter < Gherkin7Adapter
+
+  end
+
+end

data/lib/cuke_modeler/adapters/gherkin_9_adapter.rb

@@ -0,0 +1,12 @@
+require_relative 'gherkin_7_adapter'
+
+module CukeModeler
+
+  # NOT A PART OF THE PUBLIC API
+  # An adapter that can convert the output of version 9.x of the *gherkin* gem into input that is consumable by this gem.
+
+  class Gherkin9Adapter < Gherkin7Adapter
+
+  end
+
+end

data/lib/cuke_modeler/parsing.rb

@@ -1,115 +1,48 @@
-module CukeModeler
-
-  # A module providing source text parsing functionality.
-
-  module Parsing
-
-
-    # Have to at least load some version of the gem before which version of the gem has been loaded can
-    # be determined and the rest of the needed files can be loaded. Try the old one first and then the
-    # new one.
-    begin
-      require 'gherkin'
-    rescue LoadError
-      begin
-        require 'gherkin/parser'
-      rescue LoadError
-        # Gherkin 6.x
-        require 'gherkin/gherkin'
-      end
-    end
-
-
-    # The *gherkin* gem loads differently and has different grammar rules across major versions. Parsing
-    # will be done with an 'adapter' appropriate to the version of the *gherkin* gem that has been activated.
-
-    gherkin_version = Gem.loaded_specs['gherkin'].version.version
-
-    case gherkin_version
-      when /^6\./
-        require 'gherkin/gherkin'
-        require 'cuke_modeler/adapters/gherkin_6_adapter'
-
-        # NOT A PART OF THE PUBLIC API
-        # The method to use for parsing Gherkin text
-        def self.parsing_method(source_text, filename)
-          messages = Gherkin::Gherkin.from_source(filename, source_text, {:default_dialect => CukeModeler::Parsing.dialect}).to_a
-
-          messages.map(&:to_hash).find { |message| message[:gherkinDocument] }[:gherkinDocument]
-        end
-
-        # NOT A PART OF THE PUBLIC API
-        # The adapter to use when converting an AST to a standard internal shape
-        def self.adapter_class
-          CukeModeler::Gherkin6Adapter
-        end
-
-      when /^[54]\./
-        require 'gherkin/parser'
-        require 'cuke_modeler/adapters/gherkin_4_adapter'
-
-
-        # todo - make these methods private?
-        # NOT A PART OF THE PUBLIC API
-        # The method to use for parsing Gherkin text
-        # Filename isn't used by this version of Gherkin but keeping the parameter so that the calling method only has to know one method signature
-        def self.parsing_method(source_text, _filename)
-          Gherkin::Parser.new.parse(source_text)
-        end
-
-        # NOT A PART OF THE PUBLIC API
-        # The adapter to use when converting an AST to a standard internal shape
-        def self.adapter_class
-          CukeModeler::Gherkin4Adapter
-        end
+# Have to at least load some version of the gem before which version of the gem has been loaded can
+# be determined and the rest of the needed files can be loaded. The entry points vary across versions,
+# so try them all until one of them works.
+begin
+  # Gherkin 2.x, 8.x, 9.x
+  require 'gherkin'
+rescue LoadError
+  begin
+    require 'gherkin/parser'
+  rescue LoadError
+    # Gherkin 6.x, 7.x
+    require 'gherkin/gherkin'
+  end
+end
 
-      when /^3\./
-        require 'gherkin/parser'
-        require 'cuke_modeler/adapters/gherkin_3_adapter'
 
+# The *gherkin* gem loads differently and has different grammar rules across major versions. Parsing
+# will be done with an 'adapter' appropriate to the version of the *gherkin* gem that has been activated.
+
+gherkin_version = Gem.loaded_specs['gherkin'].version.version
+gherkin_major_version = gherkin_version.match(/^(\d+)\./)[1].to_i
+
+case gherkin_major_version
+  when 6, 7, 8, 9
+    require 'gherkin/dialect'
+  when 3, 4, 5
+    require 'gherkin/parser'
+  when 2
+    require 'stringio'
+    require 'gherkin/formatter/json_formatter'
+    require 'gherkin'
+    require 'json'
+    require 'multi_json'
+  else
+    raise("Unknown Gherkin version: '#{gherkin_version}'")
+end
 
-        # NOT A PART OF THE PUBLIC API
-        # The method to use for parsing Gherkin text
-        # Filename isn't used by this version of Gherkin but keeping the parameter so that the calling method only has to know one method signature
-        def self.parsing_method(source_text, _filename)
-          Gherkin::Parser.new.parse(source_text)
-        end
+require "cuke_modeler/adapters/gherkin_#{gherkin_major_version}_adapter"
 
-        # NOT A PART OF THE PUBLIC API
-        # The adapter to use when converting an AST to a standard internal shape
-        def self.adapter_class
-          CukeModeler::Gherkin3Adapter
-        end
-      when /^2\./
-        require 'stringio'
-        require 'gherkin/formatter/json_formatter'
-        require 'gherkin'
-        require 'json'
-        require 'multi_json'
-        require 'cuke_modeler/adapters/gherkin_2_adapter'
-
-
-        # NOT A PART OF THE PUBLIC API
-        # The method to use for parsing Gherkin text
-        def self.parsing_method(source_text, filename)
-          io = StringIO.new
-          formatter = Gherkin::Formatter::JSONFormatter.new(io)
-          parser = Gherkin::Parser::Parser.new(formatter)
-          parser.parse(source_text, filename, 0)
-          formatter.done
-          MultiJson.load(io.string)
-        end
 
-        # NOT A PART OF THE PUBLIC API
-        # The adapter to use when converting an AST to a standard internal shape
-        def self.adapter_class
-          CukeModeler::Gherkin2Adapter
-        end
+module CukeModeler
 
-      else
-        raise("Unknown Gherkin version: '#{gherkin_version}'")
-    end
+  # A module providing source text parsing functionality.
 
+  module Parsing
 
     class << self
 
@@ -136,17 +69,92 @@ module CukeModeler
       def parse_text(source_text, filename = 'cuke_modeler_fake_file.feature')
         raise(ArgumentError, "Text to parse must be a String but got #{source_text.class}") unless source_text.is_a?(String)
 
-
         begin
           parsed_result = parsing_method(source_text, filename)
         rescue => e
           raise(ArgumentError, "Error encountered while parsing '#{filename}'\n#{e.class} - #{e.message}")
         end
 
-        adapted_result = adapter_class.new.adapt(parsed_result)
+        adapter_class.new.adapt(parsed_result)
+      end
+
 
+      gherkin_version = Gem.loaded_specs['gherkin'].version.version
+      gherkin_major_version = gherkin_version.match(/^(\d+)\./)[1].to_i
+
+      case gherkin_major_version
+        when 9
+          # NOT A PART OF THE PUBLIC API
+          # The method to use for parsing Gherkin text
+          def parsing_method(source_text, filename)
+            messages = Gherkin.from_source(filename, source_text, { :include_gherkin_document => true }).to_a.map(&:to_hash)
+
+            potential_error_message = messages.find { |message| message[:attachment] }
+            gherkin_ast_message = messages.find { |message| message[:gherkin_document] }
+
+            if potential_error_message
+              raise potential_error_message[:attachment][:data] if potential_error_message[:attachment][:data] =~ /expected.*got/
+            end
+
+            gherkin_ast_message[:gherkin_document]
+          end
+        when 8
+          # NOT A PART OF THE PUBLIC API
+          # The method to use for parsing Gherkin text
+          def parsing_method(source_text, filename)
+            messages = Gherkin.from_source(filename, source_text, { :include_gherkin_document => true }).to_a.map(&:to_hash)
+
+            potential_error_message = messages.find { |message| message[:attachment] }
+            gherkin_ast_message = messages.find { |message| message[:gherkinDocument] }
+
+            if potential_error_message
+              raise potential_error_message[:attachment][:data] if potential_error_message[:attachment][:data] =~ /expected.*got/
+            end
+
+            gherkin_ast_message[:gherkinDocument]
+          end
+        when 6, 7
+          # NOT A PART OF THE PUBLIC API
+          # The method to use for parsing Gherkin text
+          def parsing_method(source_text, filename)
+            messages = Gherkin::Gherkin.from_source(filename, source_text).to_a.map(&:to_hash)
+
+            potential_error_message = messages.find { |message| message[:attachment] }
+            gherkin_ast_message = messages.find { |message| message[:gherkinDocument] }
+
+            if potential_error_message
+              raise potential_error_message[:attachment][:data] if potential_error_message[:attachment][:data] =~ /expected.*got/
+            end
+
+            gherkin_ast_message[:gherkinDocument]
+          end
+        when 3, 4, 5
+          # todo - make these methods private?
+          # NOT A PART OF THE PUBLIC API
+          # The method to use for parsing Gherkin text
+          # Filename isn't used by this version of Gherkin but keeping the parameter so that the calling method only has to know one method signature
+          def parsing_method(source_text, _filename)
+            Gherkin::Parser.new.parse(source_text)
+          end
+        when 2
+          # NOT A PART OF THE PUBLIC API
+          # The method to use for parsing Gherkin text
+          def parsing_method(source_text, filename)
+            io = StringIO.new
+            formatter = Gherkin::Formatter::JSONFormatter.new(io)
+            parser = Gherkin::Parser::Parser.new(formatter)
+            parser.parse(source_text, filename, 0)
+            formatter.done
+            MultiJson.load(io.string)
+          end
+        else
+          raise("Unknown Gherkin version: '#{gherkin_version}'")
+      end
 
-        adapted_result
+      # NOT A PART OF THE PUBLIC API
+      # The adapter to use when converting an AST to a standard internal shape
+      define_method('adapter_class') do
+        CukeModeler.const_get("Gherkin#{gherkin_major_version}Adapter")
       end
 
     end

data/lib/cuke_modeler/version.rb

@@ -1,4 +1,4 @@
 module CukeModeler
   # The gem version
-  VERSION = '2.0.0'
+  VERSION = '2.1.0'
 end

data/testing/gemfiles/gherkin7.gemfile

@@ -0,0 +1,9 @@
+source 'https://rubygems.org'
+
+gemspec :path => "../../"
+
+gem "gherkin", "~> 7.0"
+
+if RUBY_VERSION =~ /^2\.[23456789]/
+  gem 'test-unit'
+end

data/testing/gemfiles/gherkin8.gemfile

@@ -0,0 +1,9 @@
+source 'https://rubygems.org'
+
+gemspec :path => "../../"
+
+gem "gherkin", "~> 8.0"
+
+if RUBY_VERSION =~ /^2\.[23456789]/
+  gem 'test-unit'
+end

data/testing/gemfiles/gherkin9.gemfile

@@ -0,0 +1,9 @@
+source 'https://rubygems.org'
+
+gemspec :path => "../../"
+
+gem "gherkin", "~> 9.0"
+
+if RUBY_VERSION =~ /^2\.[23456789]/
+  gem 'test-unit'
+end

data/testing/helper_methods.rb

@@ -0,0 +1,23 @@
+module CukeModeler
+  module HelperMethods
+
+    def assert_bidirectional_equality(base_thing, compared_thing)
+      expect(base_thing).to eq(compared_thing)
+      expect(compared_thing).to eq(base_thing)
+    end
+
+    def assert_bidirectional_inequality(base_thing, compared_thing)
+      expect(base_thing).to_not eq(compared_thing)
+      expect(compared_thing).to_not eq(base_thing)
+    end
+
+    def gherkin?(*versions)
+      versions.include?(gherkin_major_version)
+    end
+
+    def gherkin_major_version
+      Gem.loaded_specs['gherkin'].version.version.match(/^(\d+)\./)[1].to_i
+    end
+
+  end
+end

data/testing/rspec/spec/integration/adapters/gherkin_2_adapter_spec.rb

@@ -1,7 +1,7 @@
 require "#{File.dirname(__FILE__)}/../../spec_helper"
 
 
-describe 'Gherkin2Adapter, Integration', :gherkin2 => true do
+describe 'Gherkin2Adapter, Integration', :if => gherkin?(2) do
 
   let(:clazz) { CukeModeler::Gherkin2Adapter }
   let(:adapter) { clazz.new }

data/testing/rspec/spec/integration/adapters/gherkin_3_adapter_spec.rb

@@ -1,7 +1,7 @@
 require "#{File.dirname(__FILE__)}/../../spec_helper"
 
 
-describe 'Gherkin3Adapter, Integration', :gherkin3 => true do
+describe 'Gherkin3Adapter, Integration', :if => gherkin?(3) do
 
   let(:clazz) { CukeModeler::Gherkin3Adapter }
   let(:adapter) { clazz.new }

data/testing/rspec/spec/integration/adapters/gherkin_4_adapter_spec.rb

@@ -1,7 +1,7 @@
 require "#{File.dirname(__FILE__)}/../../spec_helper"
 
 
-describe 'Gherkin4Adapter, Integration', :gherkin4_5 => true do
+describe 'Gherkin4Adapter, Integration', :if => gherkin?(4) do
 
   let(:clazz) { CukeModeler::Gherkin4Adapter }
   let(:adapter) { clazz.new }

data/testing/rspec/spec/integration/adapters/gherkin_5_adapter_spec.rb

@@ -0,0 +1,165 @@
+require "#{File.dirname(__FILE__)}/../../spec_helper"
+
+
+describe 'Gherkin4Adapter, Integration', :if => gherkin?(5) do
+
+  let(:clazz) { CukeModeler::Gherkin5Adapter }
+  let(:adapter) { clazz.new }
+  let(:source_text) { "# feature comment
+                       @tag1 @tag2 @tag3
+                       #{FEATURE_KEYWORD}: A feature with everything it could have
+
+                       Including a description
+                       and then some.
+
+                         # background comment
+                         #{BACKGROUND_KEYWORD}:
+
+                         Background
+                         description
+
+                           #{STEP_KEYWORD} a step
+                           # table comment
+                             | value1 |
+                           # table row comment
+                             | value2 |
+                           #{STEP_KEYWORD} another step
+
+                         # scenario comment
+                         @scenario_tag
+                         #{SCENARIO_KEYWORD}:
+
+                         Scenario
+                         description
+
+                           #{STEP_KEYWORD} a step
+                           #{STEP_KEYWORD} another step
+                             \"\"\"
+                             some text
+                             \"\"\"
+
+                         # outline comment
+                         @outline_tag
+                         #{OUTLINE_KEYWORD}:
+
+                         Outline
+                         description
+
+                           # step comment
+                           #{STEP_KEYWORD} a step
+                           # table comment
+                             | value2 |
+                           # step comment
+                           #{STEP_KEYWORD} another step
+                           # doc string comment
+                             \"\"\"
+                             some text
+                             \"\"\"
+
+                         # example comment
+                         @example_tag
+                         #{EXAMPLE_KEYWORD}:
+
+                         Example
+                         description
+
+                           # row comment
+                           | param |
+                           | value |
+                       # final comment" }
+  let(:feature_file_model) { test_file_path = CukeModeler::FileHelper.create_feature_file(:text => source_text, :name => 'adapter_test_file')
+  CukeModeler::FeatureFile.new(test_file_path) }
+  let(:feature_model) { feature_file_model.feature }
+
+
+  it "does not store parsing data for a feature file's children" do
+    model = feature_file_model
+
+    expect(model.parsing_data[:comments]).to be_nil
+    expect(model.parsing_data[:feature]).to be_nil
+  end
+
+  it "does not store parsing data for a feature's children" do
+    model = feature_model
+
+    expect(model.parsing_data[:tags]).to be_nil
+    expect(model.parsing_data[:children]).to be_nil
+  end
+
+  it "does not store parsing data for a background's children" do
+    model = feature_model.background
+
+    expect(model.parsing_data[:steps]).to be_nil
+  end
+
+  it "does not store parsing data for a scenario's children" do
+    model = feature_model.scenarios.first
+
+    expect(model.parsing_data[:tags]).to be_nil
+    expect(model.parsing_data[:steps]).to be_nil
+  end
+
+  it "does not store parsing data for an outline's children" do
+    model = feature_model.outlines.first
+
+    expect(model.parsing_data[:tags]).to be_nil
+    expect(model.parsing_data[:steps]).to be_nil
+    expect(model.parsing_data[:examples]).to be_nil
+  end
+
+  it "does not store parsing data for an example's children" do
+    model = feature_model.outlines.first.examples.first
+
+    expect(model.parsing_data[:tags]).to be_nil
+    expect(model.parsing_data[:tableHeader]).to be_nil
+    expect(model.parsing_data[:tableBody]).to be_nil
+  end
+
+  it "does not store parsing data for an example row's children" do
+    model = feature_model.outlines.first.examples.first.rows.first
+
+    expect(model.parsing_data[:cells]).to be_nil
+  end
+
+  it "does not store parsing data for a step's children, table" do
+    model = feature_model.outlines.first.steps.first
+
+    expect(model.parsing_data[:argument]).to be_nil
+  end
+
+  it "does not store parsing data for a step's children, doc string" do
+    model = feature_model.outlines.first.steps.last
+
+    expect(model.parsing_data[:argument]).to be_nil
+  end
+
+  it "does not store parsing data for a table's children" do
+    model = feature_model.outlines.first.steps.first.block
+
+    expect(model.parsing_data[:rows]).to be_nil
+  end
+
+  it "does not store parsing data for a table row's children" do
+    model = feature_model.outlines.first.steps.first.block.rows.first
+
+    expect(model.parsing_data[:cells]).to be_nil
+  end
+
+
+  describe 'stuff that is in no way part of the public API and entirely subject to change' do
+
+    it 'provides a useful explosion message if it encounters an entirely new type of test' do
+      partial_feature_ast = { :type => :Feature, :location => { :line => 1, :column => 1 }, :children => [{ :type => :some_unknown_type }] }
+
+      expect { adapter.adapt_feature!(partial_feature_ast) }.to raise_error(ArgumentError, /Unknown.*some_unknown_type/)
+    end
+
+    it 'provides a useful explosion message if it encounters an entirely new type of step block' do
+      partial_feature_ast = { :type => :Feature, :location => { :line => 1, :column => 1 }, :children => [{ :type => :Scenario, :tags => [], :location => { :line => 1, :column => 1 }, :steps => [{ :type => :Step, :location => { :line => 1, :column => 1 }, :argument => { :type => :some_unknown_type, :location => { :line => 1, :column => 1 }, :content => "" } }] }] }
+
+      expect { adapter.adapt_feature!(partial_feature_ast) }.to raise_error(ArgumentError, /Unknown.*some_unknown_type/)
+    end
+
+  end
+
+end