cuke_modeler 2.0.0 → 3.3.0

data/.gitignore

@@ -1,18 +0,0 @@
-*.gem
-*.rbc
-.bundle
-.config
-.yardoc
-Gemfile.lock
-InstalledFiles
-_yardoc
-coverage
-doc/
-lib/bundler/man
-pkg
-rdoc
-spec/reports
-test/tmp
-test/version_tmp
-tmp
-.idea/*

data/.simplecov

@@ -1,7 +0,0 @@
-SimpleCov.start do
-  root File.dirname(__FILE__)
-
-  add_filter '/testing/'
-
-  merge_timeout 300
-end

data/.travis.yml

@@ -1,63 +0,0 @@
-os:
-  - linux
-  - osx
-
-# JRuby isn't working on the new default distribution
-dist: trusty
-
-language: ruby
-rvm:
-  - 1.8.7
-  - 1.9.3
-  - 2.3.8
-  - 2.4.5
-  - 2.5.3
-  - 2.6.0
-  - jruby-9.1.7.0
-
-gemfile:
-  - testing/gemfiles/gherkin2.gemfile
-  - testing/gemfiles/gherkin3.gemfile
-  - testing/gemfiles/gherkin4.gemfile
-  - testing/gemfiles/gherkin5.gemfile
-  - testing/gemfiles/gherkin6.gemfile
-
-matrix:
-  exclude:
-  # gherkin 3.x does not work with Ruby 1.8.x
-  - rvm: 1.8.7
-    gemfile: testing/gemfiles/gherkin3.gemfile
-  # gherkin 4.x does not work with Ruby 1.8.x
-  - rvm: 1.8.7
-    gemfile: testing/gemfiles/gherkin4.gemfile
-  # 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: use once protobuf is updated
-  # gherkin 6.x uses protobuf, which does not work with Ruby 2.6.x
-  - rvm: 2.6.0
-    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
-
-before_install:
-  - gem install bundler -v '< 2'
-  
-script: bundle exec rake cuke_modeler:ci_build

data/Gemfile

@@ -1,37 +0,0 @@
-source 'http://rubygems.org'
-
-# Specify your gem's dependencies in cuke_modeler.gemspec
-gemspec
-
-# cuke_modeler can play with pretty much any version of these but they all play differently with Ruby
-
-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
-
-  if RUBY_VERSION =~ /^1\.8/
-    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 'rainbow', '< 2.0' # 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\./
-
-  if RUBY_VERSION =~ /^2\.[23456789]/
-    gem 'test-unit'
-  end
-
-  gem 'gherkin', '~> 6.0'
-  gem 'cucumber', '~>4.0.rc'
-end

data/Rakefile

@@ -1,73 +0,0 @@
-require "bundler/gem_tasks"
-require 'rake'
-require 'racatt'
-require 'coveralls/rake/task'
-require 'rainbow'
-
-
-Rainbow.enabled = true
-
-namespace 'racatt' do
-  Racatt.create_tasks
-end
-
-
-namespace 'cuke_modeler' do
-
-  desc 'Removes the current code coverage data'
-  task :clear_coverage do
-    code_coverage_directory = "#{File.dirname(__FILE__)}/coverage"
-
-    FileUtils.remove_dir(code_coverage_directory, true)
-  end
-
-  desc 'Check documentation with RDoc'
-  task :check_documentation do
-    output = `rdoc lib -C`
-    puts output
-
-    if output =~ /100.00% documented/
-      puts Rainbow('All code documented').green
-    else
-      raise Rainbow('Parts of the gem are undocumented').red
-    end
-  end
-
-  desc 'Run all of the tests'
-  task :test_everything => [:clear_coverage] do
-    rspec_args = '--tag ~@wip --pattern "testing/rspec/spec/**/*_spec.rb" --force-color'
-
-    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 --color'
-    else
-      cucumber_args = "testing/cucumber/features -r testing/cucumber/support -r testing/cucumber/step_definitions -f progress -t 'not @wip' --color"
-    end
-
-    Rake::Task['racatt:test_everything'].invoke(rspec_args, cucumber_args)
-  end
-
-  # creates coveralls:push task
-  Coveralls::RakeTask.new
-
-  desc 'The task that CI will run. Do not run locally.'
-  task :ci_build => ['cuke_modeler:test_everything', 'coveralls:push']
-
-  desc 'Check that things look good before trying to release'
-  task :prerelease_check do
-    begin
-      Rake::Task['cuke_modeler:test_everything'].invoke
-      Rake::Task['cuke_modeler:check_documentation'].invoke
-    rescue => e
-      puts Rainbow("Something isn't right!").red
-      raise e
-    end
-
-    puts Rainbow('All is well. :)').green
-  end
-
-end
-
-
-task :default => 'cuke_modeler:test_everything'

data/appveyor.yml

@@ -1,61 +0,0 @@
-version: '1.0.{build}'
-
-environment:
-  matrix:
-
-      # 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: 24-x64
-      BUNDLE_GEMFILE: testing/gemfiles/gherkin2.gemfile
-    - RUBY_VERSION: 25-x64
-      BUNDLE_GEMFILE: testing/gemfiles/gherkin2.gemfile
-
-    - RUBY_VERSION: 24
-      BUNDLE_GEMFILE: testing/gemfiles/gherkin3.gemfile
-    - RUBY_VERSION: 24-x64
-      BUNDLE_GEMFILE: testing/gemfiles/gherkin3.gemfile
-    - RUBY_VERSION: 25
-      BUNDLE_GEMFILE: testing/gemfiles/gherkin3.gemfile
-    - RUBY_VERSION: 25-x64
-      BUNDLE_GEMFILE: testing/gemfiles/gherkin3.gemfile
-
-    - RUBY_VERSION: 24
-      BUNDLE_GEMFILE: testing/gemfiles/gherkin4.gemfile
-    - RUBY_VERSION: 24-x64
-      BUNDLE_GEMFILE: testing/gemfiles/gherkin4.gemfile
-    - RUBY_VERSION: 25
-      BUNDLE_GEMFILE: testing/gemfiles/gherkin4.gemfile
-    - RUBY_VERSION: 25-x64
-      BUNDLE_GEMFILE: testing/gemfiles/gherkin4.gemfile
-
-    - RUBY_VERSION: 24
-      BUNDLE_GEMFILE: testing/gemfiles/gherkin5.gemfile
-    - RUBY_VERSION: 24-x64
-      BUNDLE_GEMFILE: testing/gemfiles/gherkin5.gemfile
-    - RUBY_VERSION: 25
-      BUNDLE_GEMFILE: testing/gemfiles/gherkin5.gemfile
-    - RUBY_VERSION: 25-x64
-      BUNDLE_GEMFILE: testing/gemfiles/gherkin5.gemfile
-
-      # Gherkin 6.x requires at least Ruby 2.2
-    - RUBY_VERSION: 24
-      BUNDLE_GEMFILE: testing/gemfiles/gherkin6.gemfile
-    - RUBY_VERSION: 24-x64
-      BUNDLE_GEMFILE: testing/gemfiles/gherkin6.gemfile
-    - RUBY_VERSION: 25
-      BUNDLE_GEMFILE: testing/gemfiles/gherkin6.gemfile
-    - RUBY_VERSION: 25-x64
-      BUNDLE_GEMFILE: testing/gemfiles/gherkin6.gemfile
-
-install:
-  - set PATH=C:\Ruby%RUBY_VERSION%\bin;%PATH%
-  - bundle install
-
-build: off
-
-before_test:
-  - ruby -v
-  - gem -v
-  - bundle -v
-
-test_script:
-  - bundle exec rake cuke_modeler:ci_build

data/lib/cuke_modeler/adapters/gherkin_2_adapter.rb

@@ -1,274 +0,0 @@
-module CukeModeler
-
-  # NOT A PART OF THE PUBLIC API
-  # An adapter that can convert the output of version 2.x of the *gherkin* gem into input that is consumable by this gem.
-
-  class Gherkin2Adapter
-
-    # Adapts the given AST into the shape that this gem expects
-    def adapt(parsed_ast)
-      parsed_data = {}
-
-      # The entire AST is just an array with one feature and we don't want to save any child data so...an empty array
-      parsed_data['cuke_modeler_parsing_data'] = []
-
-      # Comments are stored on child elements in gherkin 2.x
-      comments = []
-
-      # An AST is just one feature
-      adapt_feature!(parsed_ast.first, comments) if parsed_ast.first
-      parsed_data['feature'] = parsed_ast.first
-
-      # Adapt and store comments once they have all been gathered
-      comments.each do |comment|
-        adapt_comment!(comment)
-      end
-      parsed_data['comments'] = comments
-
-
-      [parsed_data]
-    end
-
-    # Adapts the AST sub-tree that is rooted at the given feature node.
-    def adapt_feature!(parsed_feature, gathered_comments)
-      # 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']['elements'] = nil
-
-      if parsed_feature['comments']
-        parsed_feature['cuke_modeler_parsing_data']['comments'] = nil
-        gathered_comments.concat(parsed_feature['comments'])
-      end
-
-      adapt_child_elements!(parsed_feature, gathered_comments)
-
-      if parsed_feature['tags']
-        parsed_feature['tags'].each do |tag|
-          adapt_tag!(tag)
-        end
-      end
-    end
-
-    # Adapts the AST sub-tree that is rooted at the given background node.
-    def adapt_background!(parsed_background, gathered_comments)
-      # 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']['steps'] = nil
-
-      if parsed_background['comments']
-        parsed_background['cuke_modeler_parsing_data']['comments'] = nil
-        gathered_comments.concat(parsed_background['comments'])
-      end
-
-      if parsed_background['steps']
-        parsed_background['steps'].each do |step|
-          adapt_step!(step, gathered_comments)
-        end
-      end
-    end
-
-    # Adapts the AST sub-tree that is rooted at the given scenario node.
-    def adapt_scenario!(parsed_scenario, gathered_comments)
-      # Saving off the original data
-      parsed_scenario['cuke_modeler_parsing_data'] = Marshal::load(Marshal.dump(parsed_scenario))
-
-      # Removing parsed data for child elements in order to avoid duplicating data
-      parsed_scenario['cuke_modeler_parsing_data']['tags'] = nil
-      parsed_scenario['cuke_modeler_parsing_data']['steps'] = nil
-
-      if parsed_scenario['comments']
-        parsed_scenario['cuke_modeler_parsing_data']['comments'] = nil
-        gathered_comments.concat(parsed_scenario['comments'])
-      end
-
-      if parsed_scenario['tags']
-        parsed_scenario['tags'].each do |tag|
-          adapt_tag!(tag)
-        end
-      end
-
-      if parsed_scenario['steps']
-        parsed_scenario['steps'].each do |step|
-          adapt_step!(step, gathered_comments)
-        end
-      end
-    end
-
-    # Adapts the AST sub-tree that is rooted at the given outline node.
-    def adapt_outline!(parsed_outline, gathered_comments)
-      # Saving off the original data
-      parsed_outline['cuke_modeler_parsing_data'] = Marshal::load(Marshal.dump(parsed_outline))
-
-      # Removing parsed data for child elements in order to avoid duplicating data
-      parsed_outline['cuke_modeler_parsing_data']['tags'] = nil
-      parsed_outline['cuke_modeler_parsing_data']['steps'] = nil
-      parsed_outline['cuke_modeler_parsing_data']['examples'] = nil
-
-      if parsed_outline['comments']
-        parsed_outline['cuke_modeler_parsing_data']['comments'] = nil
-        gathered_comments.concat(parsed_outline['comments'])
-      end
-
-      if parsed_outline['tags']
-        parsed_outline['tags'].each do |tag|
-          adapt_tag!(tag)
-        end
-      end
-
-      if parsed_outline['steps']
-        parsed_outline['steps'].each do |step|
-          adapt_step!(step, gathered_comments)
-        end
-      end
-
-      if parsed_outline['examples']
-        parsed_outline['examples'].each do |example|
-          adapt_example!(example, gathered_comments)
-        end
-      end
-    end
-
-    # Adapts the AST sub-tree that is rooted at the given example node.
-    def adapt_example!(parsed_example, gathered_comments)
-      # 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']['rows'] = nil
-
-      if parsed_example['comments']
-        parsed_example['cuke_modeler_parsing_data']['comments'] = nil
-        gathered_comments.concat(parsed_example['comments'])
-      end
-
-      parsed_example['rows'].each do |row|
-        adapt_table_row!(row, gathered_comments)
-      end
-
-      if parsed_example['tags']
-        parsed_example['tags'].each do |tag|
-          adapt_tag!(tag)
-        end
-      end
-    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))
-    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('value')
-      parsed_comment['line'] = parsed_comment.delete('line')
-    end
-
-    # Adapts the AST sub-tree that is rooted at the given step node.
-    def adapt_step!(parsed_step, gathered_comments)
-      # 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']['rows'] = nil if parsed_step['cuke_modeler_parsing_data']['rows']
-      parsed_step['cuke_modeler_parsing_data']['doc_string'] = nil if parsed_step['cuke_modeler_parsing_data']['doc_string']
-
-      if parsed_step['comments']
-        parsed_step['cuke_modeler_parsing_data']['comments'] = nil
-        gathered_comments.concat(parsed_step['comments'])
-      end
-
-      adapt_doc_string!(parsed_step['doc_string']) if parsed_step['doc_string']
-
-      if parsed_step['rows']
-        parsed_step['table'] = {'rows' => parsed_step['rows']}
-        adapt_step_table!(parsed_step['table'], gathered_comments)
-      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))
-    end
-
-    # Adapts the AST sub-tree that is rooted at the given table node.
-    def adapt_step_table!(parsed_step_table, gathered_comments)
-      # Saving off the original data
-      parsed_step_table['cuke_modeler_parsing_data'] = Marshal::load(Marshal.dump(parsed_step_table['rows']))
-
-      # Removing parsed data for child elements in order to avoid duplicating data
-      parsed_step_table['cuke_modeler_parsing_data'].clear
-
-
-      parsed_step_table['line'] = parsed_step_table['rows'].first['line']
-
-      parsed_step_table['rows'].each do |row|
-        adapt_table_row!(row, gathered_comments)
-      end
-    end
-
-    # Adapts the AST sub-tree that is rooted at the given row node.
-    def adapt_table_row!(parsed_table_row, gathered_comments)
-      # 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
-
-      if parsed_table_row['comments']
-        parsed_table_row['cuke_modeler_parsing_data']['comments'] = nil
-        gathered_comments.concat(parsed_table_row['comments'])
-      end
-
-      parsed_table_row['cells'].collect! do |cell|
-        create_cell_for(cell, parsed_table_row['line'])
-      end
-    end
-
-    # Adapts the AST sub-tree that is rooted at the given cell node.
-    def create_cell_for(parsed_cell, line_number)
-      cell = {}
-
-      # Saving off the original data
-      cell['cuke_modeler_parsing_data'] = Marshal::load(Marshal.dump(parsed_cell))
-
-      cell['value'] = parsed_cell
-      cell['line'] = line_number
-
-
-      cell
-    end
-
-
-    private
-
-
-    def adapt_child_elements!(parsed_feature, gathered_comments)
-      if parsed_feature['elements']
-        parsed_feature['elements'].each do |element|
-          case element['type']
-            when 'background'
-              adapt_background!(element, gathered_comments)
-            when 'scenario'
-              adapt_scenario!(element, gathered_comments)
-            when 'scenario_outline'
-              adapt_outline!(element, gathered_comments)
-            else
-              raise(ArgumentError, "Unknown element type: #{element['type']}")
-          end
-        end
-      end
-    end
-
-  end
-end