cuke_modeler 1.3.0 → 1.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 6f6ce507c3e4cce81b178759608f8421995acb33
-  data.tar.gz: 28e38d785382112db34e4bd8ad21c2ab2d520fb2
+SHA256:
+  metadata.gz: 76a8b71aee8bdbf79c8cf429c31fc694edaa85514a5ca5620952b033e8f237cb
+  data.tar.gz: 2a935d1f999d3b0a31a0a72c6b2dd2c4f419a5c79bcbe8bb88e012280bcee06b
 SHA512:
-  metadata.gz: 6468b515b7f55540cf96319c3862ef04d7560b583294a694c71a3077becc915516465dec013e414c24d05b6fe8cfa0ef37844b4eab23dc1f62068b876b0fa17c
-  data.tar.gz: c636a5d624e5ad31be581134f0429bf63cd2d52bbef6a0278c5484ac8a2d0e18519e0d372051d5de44f4a012959dd7d93801559eda4f693e44247b779dd0c210
+  metadata.gz: 9608da985b4103317a66f4490a32925ec48a084cee57ecb273e4536b5d1fb30564edc0355917f30e9c98e1f2da7531f28242874f85207aeb7f25d5a0835406ee
+  data.tar.gz: 769dbd96bb7c6f079166747666e6a5307e69949e5a9bc3af0d562c1ddac44873bda92a935b32bd3dec3f16bf66c6aaab093eace3534bbab7c30ce15caf1d4cc5

data/.travis.yml

@@ -15,6 +15,7 @@ gemfile:
   - testing/gemfiles/gherkin3.gemfile
   - testing/gemfiles/gherkin4.gemfile
   - testing/gemfiles/gherkin5.gemfile
+  - testing/gemfiles/gherkin6.gemfile
 
 matrix:
   exclude:
@@ -27,9 +28,24 @@ matrix:
   # gherkin 5.x does not work with Ruby 1.8.x
   - rvm: 1.8.7
     gemfile: testing/gemfiles/gherkin5.gemfile
+  # gherkin 6.x does not work with Ruby 1.8.x
+  - rvm: 1.8.7
+    gemfile: testing/gemfiles/gherkin6.gemfile
+  # gherkin 6.x does not work with Ruby 1.9.x
+  - rvm: 1.9.3
+    gemfile: testing/gemfiles/gherkin6.gemfile
+
+  # TODO: turn this back on
+  # gherkin 6.x relies on 'google-protobuf', which does not currently work on JRuby (https://github.com/protocolbuffers/protobuf/issues/1594)
+  - rvm: jruby-9.1.7.0
+    gemfile: testing/gemfiles/gherkin6.gemfile
+
   # Travis does not provide 1.8.7 on OSX
   - rvm: 1.8.7
     os: osx
+  # Travis does not provide 1.9.3 on OSX
+  - rvm: 1.9.3
+    os: osx
 
 # todo - Remove this once TravisCI fixes their bundler issue (https://github.com/alphagov/govuk_template/pull/186)
 before_install:

data/Gemfile

@@ -1,4 +1,4 @@
-source 'https://rubygems.org'
+source 'http://rubygems.org'
 
 # Specify your gem's dependencies in cuke_modeler.gemspec
 gemspec
@@ -7,6 +7,11 @@ gemspec
 
 if RUBY_VERSION =~ /^1\./
 
+  if RbConfig::CONFIG['host_os'].downcase =~ /mswin|msys|mingw32/
+    gem 'ffi', '< 1.9.15' # The 'ffi' gem, for Windows, requires Ruby 2.x on/after this version
+  end
+
+  gem 'unf_ext', '< 0.0.7.3' # Requires Ruby 2.x on/after this version
   gem 'tins', '< 1.7' # The 'tins' gem requires Ruby 2.x on/after this version
   gem 'json', '< 2.0' # The 'json' gem drops pre-Ruby 2.x support on/after this version
   gem 'term-ansicolor', '< 1.4' # The 'term-ansicolor' gem requires Ruby 2.x on/after this version
@@ -15,6 +20,9 @@ if RUBY_VERSION =~ /^1\./
     gem 'cucumber', '~> 1.0' # Ruby 1.8.x support dropped after this version
     gem 'gherkin', '< 2.12.1' # Ruby 1.8.x support dropped after this version
     gem 'rake', '< 11.0' # Ruby 1.8.x support dropped after this version
+  else
+    gem 'rake', '< 12.3.0' # Ruby 1.9.x support dropped after this version
+    gem 'cucumber', '< 3.0.0' # Ruby 1.9.x support dropped after this version
   end
 
 elsif RUBY_VERSION =~ /^2\./
@@ -23,6 +31,6 @@ elsif RUBY_VERSION =~ /^2\./
     gem 'test-unit'
   end
 
-  gem 'gherkin', '~> 5.0'
-
+  gem 'gherkin', '~> 6.0'
+  gem 'cucumber', '~>4.0.rc'
 end

data/History.md

@@ -1,3 +1,8 @@
+### Version 1.4.0 / 2018-11-14
+
+* Now compatible with Gherkin 6.x.
+
+
 ### Version 1.3.0 / 2017-10-19
 
 * Now compatible with Gherkin 5.x.

data/LICENSE.txt

@@ -1,4 +1,4 @@
-Copyright (c) 2014-2017 Eric Kessler, et al
+Copyright (c) 2014-2018 Eric Kessler, et al
 
 MIT License
 

data/Rakefile

@@ -26,7 +26,14 @@ namespace 'cuke_modeler' do
   desc 'Test gem based on Ruby/dependency versions'
   task :smart_test do |t, args|
     rspec_args = '--tag ~@wip --pattern testing/rspec/spec/**/*_spec.rb'
-    cucumber_args = 'testing/cucumber/features -r testing/cucumber/support -r testing/cucumber/step_definitions -f progress -t ~@wip'
+
+    cucumber_version = Gem.loaded_specs['cucumber'].version.version
+
+    if cucumber_version =~ /^[123]\./
+      cucumber_args = 'testing/cucumber/features -r testing/cucumber/support -r testing/cucumber/step_definitions -f progress -t ~@wip'
+    else
+      cucumber_args = "testing/cucumber/features -r testing/cucumber/support -r testing/cucumber/step_definitions -f progress -t 'not @wip'"
+    end
 
     Rake::Task['cuke_modeler:test_everything'].invoke(rspec_args, cucumber_args)
   end

data/appveyor.yml

@@ -2,37 +2,32 @@ version: '1.0.{build}'
 
 environment:
   matrix:
-    - RUBY_VERSION: 193
-      BUNDLE_GEMFILE: testing/gemfiles/gherkin2.gemfile
-      # AppVeyor does not have a 64-bit Ruby 1.9.3
+
       # Gherkin 2.x does not appear to support 32-bit Ruby 2.x and it's not worth it to investigate if this is true or not
     - RUBY_VERSION: 23-x64
       BUNDLE_GEMFILE: testing/gemfiles/gherkin2.gemfile
 
-    - RUBY_VERSION: 193
-      BUNDLE_GEMFILE: testing/gemfiles/gherkin3.gemfile
-      # AppVeyor does not have a 64-bit Ruby 1.9.3
     - RUBY_VERSION: 23
       BUNDLE_GEMFILE: testing/gemfiles/gherkin3.gemfile
     - RUBY_VERSION: 23-x64
       BUNDLE_GEMFILE: testing/gemfiles/gherkin3.gemfile
 
-    - RUBY_VERSION: 193
-      BUNDLE_GEMFILE: testing/gemfiles/gherkin4.gemfile
-      # AppVeyor does not have a 64-bit Ruby 1.9.3
     - RUBY_VERSION: 23
       BUNDLE_GEMFILE: testing/gemfiles/gherkin4.gemfile
     - RUBY_VERSION: 23-x64
       BUNDLE_GEMFILE: testing/gemfiles/gherkin4.gemfile
 
-    - RUBY_VERSION: 193
-      BUNDLE_GEMFILE: testing/gemfiles/gherkin5.gemfile
-      # AppVeyor does not have a 64-bit Ruby 1.9.3
     - RUBY_VERSION: 23
       BUNDLE_GEMFILE: testing/gemfiles/gherkin5.gemfile
     - RUBY_VERSION: 23-x64
       BUNDLE_GEMFILE: testing/gemfiles/gherkin5.gemfile
 
+      # Gherkin 6.x requires at least Ruby 2.2
+    - RUBY_VERSION: 23
+      BUNDLE_GEMFILE: testing/gemfiles/gherkin6.gemfile
+    - RUBY_VERSION: 23-x64
+      BUNDLE_GEMFILE: testing/gemfiles/gherkin6.gemfile
+
 install:
   - set PATH=C:\Ruby%RUBY_VERSION%\bin;%PATH%
   - bundle install

data/cuke_modeler.gemspec

@@ -18,13 +18,13 @@ Gem::Specification.new do |spec|
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ["lib"]
 
-  spec.add_runtime_dependency 'gherkin', '< 6.0'
+  spec.add_runtime_dependency 'gherkin', '< 7.0'
   spec.add_runtime_dependency('json', '>= 1.0', '< 3.0')
   spec.add_runtime_dependency('multi_json', '~> 1.0')
 
   spec.add_development_dependency "bundler", "~> 1.5"
   spec.add_development_dependency "rake", '< 13.0.0'
-  spec.add_development_dependency 'cucumber', '< 3.0.0'
+  spec.add_development_dependency 'cucumber', '< 5.0.0'
   spec.add_development_dependency 'rspec', '~> 3.0'
   spec.add_development_dependency 'simplecov', '< 1.0.0'
   spec.add_development_dependency 'racatt', '~> 1.0'

data/lib/cuke_modeler/adapters/gherkin_6_adapter.rb

@@ -0,0 +1,309 @@
+module CukeModeler
+
+  # An adapter that can convert the output of version 6.x of the *gherkin* gem into input that is consumable by this gem.
+
+  class Gherkin6Adapter
+
+    # Adapts the given AST into the shape that this gem expects
+    def adapt(parsed_ast)
+      # Saving off the original data
+      parsed_ast['cuke_modeler_parsing_data'] = Marshal::load(Marshal.dump(parsed_ast))
+
+      # Removing parsed data for child elements in order to avoid duplicating data
+      parsed_ast['cuke_modeler_parsing_data'][:feature] = nil
+      parsed_ast['cuke_modeler_parsing_data'][:comments] = nil
+
+      # Comments are stored on the feature file in gherkin 4.x
+      parsed_ast['comments'] = []
+      parsed_ast[:comments].each do |comment|
+        adapt_comment!(comment)
+      end
+      parsed_ast['comments'].concat(parsed_ast.delete(:comments))
+
+      adapt_feature!(parsed_ast[:feature]) if parsed_ast[:feature]
+      parsed_ast['feature'] = parsed_ast.delete(:feature)
+
+      [parsed_ast]
+    end
+
+    # Adapts the AST sub-tree that is rooted at the given feature node.
+    def adapt_feature!(parsed_feature)
+      # Saving off the original data
+      parsed_feature['cuke_modeler_parsing_data'] = Marshal::load(Marshal.dump(parsed_feature))
+
+      # Removing parsed data for child elements in order to avoid duplicating data
+      parsed_feature['cuke_modeler_parsing_data'][:tags] = nil
+      parsed_feature['cuke_modeler_parsing_data'][:children] = nil
+
+      parsed_feature['keyword'] = parsed_feature.delete(:keyword)
+      parsed_feature['name'] = parsed_feature.delete(:name)
+      parsed_feature['description'] = parsed_feature.delete(:description)
+      parsed_feature['line'] = parsed_feature.delete(:location)[:line]
+
+      parsed_feature['elements'] = []
+      adapt_child_elements!(parsed_feature[:children])
+      parsed_feature['elements'].concat(parsed_feature.delete(:children))
+
+      parsed_feature['tags'] = []
+      parsed_feature[:tags].each do |tag|
+        adapt_tag!(tag)
+      end
+      parsed_feature['tags'].concat(parsed_feature.delete(:tags))
+    end
+
+    # Adapts the AST sub-tree that is rooted at the given background node.
+    def adapt_background!(parsed_background)
+      # Saving off the original data
+      parsed_background['cuke_modeler_parsing_data'] = Marshal::load(Marshal.dump(parsed_background))
+
+      # Removing parsed data for child elements in order to avoid duplicating data
+      parsed_background['cuke_modeler_parsing_data'][:background][:steps] = nil
+
+      parsed_background['type'] = 'Background'
+      parsed_background['keyword'] = parsed_background[:background].delete(:keyword)
+      parsed_background['name'] = parsed_background[:background].delete(:name)
+      parsed_background['description'] = parsed_background[:background].delete(:description)
+      parsed_background['line'] = parsed_background[:background].delete(:location)[:line]
+
+      parsed_background['steps'] = []
+      parsed_background[:background][:steps].each do |step|
+        adapt_step!(step)
+      end
+      parsed_background['steps'].concat(parsed_background[:background].delete(:steps))
+    end
+
+    # Adapts the AST sub-tree that is rooted at the given scenario node.
+    def adapt_scenario!(parsed_test)
+      # Removing parsed data for child elements in order to avoid duplicating data
+      parsed_test['cuke_modeler_parsing_data'][:scenario][:tags] = nil
+      parsed_test['cuke_modeler_parsing_data'][:scenario][:steps] = nil
+
+      parsed_test['type'] = 'Scenario'
+      parsed_test['keyword'] = parsed_test[:scenario].delete(:keyword)
+      parsed_test['name'] = parsed_test[:scenario].delete(:name)
+      parsed_test['description'] = parsed_test[:scenario].delete(:description)
+      parsed_test['line'] = parsed_test[:scenario].delete(:location)[:line]
+
+      parsed_test['tags'] = []
+      parsed_test[:scenario][:tags].each do |tag|
+        adapt_tag!(tag)
+      end
+      parsed_test['tags'].concat(parsed_test[:scenario].delete(:tags))
+
+      parsed_test['steps'] = []
+      parsed_test[:scenario][:steps].each do |step|
+        adapt_step!(step)
+      end
+      parsed_test['steps'].concat(parsed_test[:scenario].delete(:steps))
+    end
+
+    # Adapts the AST sub-tree that is rooted at the given outline node.
+    def adapt_outline!(parsed_test)
+      # Removing parsed data for child elements in order to avoid duplicating data
+      parsed_test['cuke_modeler_parsing_data'][:scenario][:tags] = nil
+      parsed_test['cuke_modeler_parsing_data'][:scenario][:steps] = nil
+      parsed_test['cuke_modeler_parsing_data'][:scenario][:examples] = nil
+
+      parsed_test['type'] = 'ScenarioOutline'
+      parsed_test['keyword'] = parsed_test[:scenario].delete(:keyword)
+      parsed_test['name'] = parsed_test[:scenario].delete(:name)
+      parsed_test['description'] = parsed_test[:scenario].delete(:description)
+      parsed_test['line'] = parsed_test[:scenario].delete(:location)[:line]
+
+      parsed_test['tags'] = []
+      parsed_test[:scenario][:tags].each do |tag|
+        adapt_tag!(tag)
+      end
+      parsed_test['tags'].concat(parsed_test[:scenario].delete(:tags))
+
+      parsed_test['steps'] = []
+      parsed_test[:scenario][:steps].each do |step|
+        adapt_step!(step)
+      end
+      parsed_test['steps'].concat(parsed_test[:scenario].delete(:steps))
+
+      parsed_test['examples'] = []
+      parsed_test[:scenario][:examples].each do |step|
+        adapt_example!(step)
+      end
+      parsed_test['examples'].concat(parsed_test[:scenario].delete(:examples))
+    end
+
+    # Adapts the AST sub-tree that is rooted at the given example node.
+    def adapt_example!(parsed_example)
+      # Saving off the original data
+      parsed_example['cuke_modeler_parsing_data'] = Marshal::load(Marshal.dump(parsed_example))
+
+      # Removing parsed data for child elements in order to avoid duplicating data
+      parsed_example['cuke_modeler_parsing_data'][:tags] = nil
+      parsed_example['cuke_modeler_parsing_data'][:table_header] = nil
+      parsed_example['cuke_modeler_parsing_data'][:table_body] = nil
+
+      parsed_example['keyword'] = parsed_example.delete(:keyword)
+      parsed_example['name'] = parsed_example.delete(:name)
+      parsed_example['line'] = parsed_example.delete(:location)[:line]
+      parsed_example['description'] = parsed_example.delete(:description)
+
+      parsed_example['rows'] = []
+
+      if parsed_example[:table_header]
+        adapt_table_row!(parsed_example[:table_header])
+        parsed_example['rows'] << parsed_example.delete(:table_header)
+      end
+
+      if parsed_example[:table_body]
+
+        parsed_example[:table_body].each do |row|
+          adapt_table_row!(row)
+        end
+        parsed_example['rows'].concat(parsed_example.delete(:table_body))
+      end
+
+
+      parsed_example['tags'] = []
+      parsed_example[:tags].each do |tag|
+        adapt_tag!(tag)
+      end
+      parsed_example['tags'].concat(parsed_example.delete(:tags))
+    end
+
+    # Adapts the AST sub-tree that is rooted at the given tag node.
+    def adapt_tag!(parsed_tag)
+      # Saving off the original data
+      parsed_tag['cuke_modeler_parsing_data'] = Marshal::load(Marshal.dump(parsed_tag))
+
+      parsed_tag['name'] = parsed_tag.delete(:name)
+      parsed_tag['line'] = parsed_tag.delete(:location)[:line]
+    end
+
+    # Adapts the AST sub-tree that is rooted at the given comment node.
+    def adapt_comment!(parsed_comment)
+      # Saving off the original data
+      parsed_comment['cuke_modeler_parsing_data'] = Marshal::load(Marshal.dump(parsed_comment))
+
+      parsed_comment['text'] = parsed_comment.delete(:text)
+      parsed_comment['line'] = parsed_comment.delete(:location)[:line]
+    end
+
+    # Adapts the AST sub-tree that is rooted at the given step node.
+    def adapt_step!(parsed_step)
+      # Saving off the original data
+      parsed_step['cuke_modeler_parsing_data'] = Marshal::load(Marshal.dump(parsed_step))
+
+      # Removing parsed data for child elements in order to avoid duplicating data
+      parsed_step['cuke_modeler_parsing_data'][:data_table] = nil
+      parsed_step['cuke_modeler_parsing_data'][:doc_string] = nil
+
+      parsed_step['keyword'] = parsed_step.delete(:keyword)
+      parsed_step['name'] = parsed_step.delete(:text)
+      parsed_step['line'] = parsed_step.delete(:location)[:line]
+
+
+      case
+        when parsed_step[:doc_string]
+          adapt_doc_string!(parsed_step[:doc_string])
+          parsed_step['doc_string'] = parsed_step.delete(:doc_string)
+        when parsed_step[:data_table]
+          adapt_step_table!(parsed_step[:data_table])
+          parsed_step['table'] = parsed_step.delete(:data_table)
+        else
+          # Step has no extra argument
+      end
+    end
+
+    # Adapts the AST sub-tree that is rooted at the given doc string node.
+    def adapt_doc_string!(parsed_doc_string)
+      # Saving off the original data
+      parsed_doc_string['cuke_modeler_parsing_data'] = Marshal::load(Marshal.dump(parsed_doc_string))
+
+      parsed_doc_string['value'] = parsed_doc_string.delete(:content)
+      parsed_doc_string['content_type'] = parsed_doc_string.delete(:content_type).strip # TODO: fix bug in Gherkin so that this whitespace is already trimmed off
+      parsed_doc_string['line'] = parsed_doc_string.delete(:location)[:line]
+    end
+
+    # Adapts the AST sub-tree that is rooted at the given table node.
+    def adapt_step_table!(parsed_step_table)
+      # Saving off the original data
+      parsed_step_table['cuke_modeler_parsing_data'] = Marshal::load(Marshal.dump(parsed_step_table))
+
+      # Removing parsed data for child elements in order to avoid duplicating data
+      parsed_step_table['cuke_modeler_parsing_data'][:rows] = nil
+
+      parsed_step_table['rows'] = []
+      parsed_step_table[:rows].each do |row|
+        adapt_table_row!(row)
+      end
+      parsed_step_table['rows'].concat(parsed_step_table.delete(:rows))
+      parsed_step_table['line'] = parsed_step_table.delete(:location)[:line]
+    end
+
+    # Adapts the AST sub-tree that is rooted at the given row node.
+    def adapt_table_row!(parsed_table_row)
+      # Saving off the original data
+      parsed_table_row['cuke_modeler_parsing_data'] = Marshal::load(Marshal.dump(parsed_table_row))
+
+      # Removing parsed data for child elements in order to avoid duplicating data which the child elements will themselves include
+      parsed_table_row['cuke_modeler_parsing_data'][:cells] = nil
+
+
+      parsed_table_row['line'] = parsed_table_row.delete(:location)[:line]
+
+      parsed_table_row['cells'] = []
+      parsed_table_row[:cells].each do |row|
+        adapt_table_cell!(row)
+      end
+      parsed_table_row['cells'].concat(parsed_table_row.delete(:cells))
+    end
+
+    # Adapts the AST sub-tree that is rooted at the given cell node.
+    def adapt_table_cell!(parsed_cell)
+      # Saving off the original data
+      parsed_cell['cuke_modeler_parsing_data'] = Marshal::load(Marshal.dump(parsed_cell))
+
+      parsed_cell['value'] = parsed_cell.delete(:value)
+      parsed_cell['line'] = parsed_cell.delete(:location)[:line]
+    end
+
+
+    private
+
+
+    def adapt_child_elements!(parsed_children)
+      return if parsed_children.empty?
+
+      background_child = parsed_children.find { |child| child[:background] }
+
+      if background_child
+        adapt_background!(background_child)
+
+        remaining_children = parsed_children.reject { |child| child[:background] }
+      end
+
+      adapt_tests!(remaining_children || parsed_children)
+    end
+
+    def adapt_tests!(parsed_tests)
+      return unless parsed_tests
+
+      parsed_tests.each do |test|
+        adapt_test!(test)
+      end
+    end
+
+    def adapt_test!(parsed_test)
+      # Saving off the original data
+      parsed_test['cuke_modeler_parsing_data'] = Marshal::load(Marshal.dump(parsed_test))
+
+
+      case
+        when parsed_test[:scenario] && parsed_test[:scenario][:examples].any?
+          adapt_outline!(parsed_test)
+        when parsed_test[:scenario]
+          adapt_scenario!(parsed_test)
+        else
+          raise(ArgumentError, "Unknown test type with keys: #{parsed_test.keys}")
+      end
+    end
+
+  end
+end