cuke_modeler 0.0.2 → 0.1.0

data/gemfiles/gherkin.gemfile

@@ -0,0 +1,17 @@
+source 'https://rubygems.org'
+
+gemspec :path => "../"
+gem "gherkin", "< 3.0.0"
+
+# cuke_modeler can play with pretty much any version of these but they all play differently with Ruby
+if RUBY_VERSION =~ /^1\.8/
+  gem 'cucumber', '<1.3.0'
+  gem 'mime-types', '<2.0.0'
+  gem 'rest-client', '<1.7.0'
+elsif RUBY_VERSION =~ /^1\./
+  gem 'cucumber', '>=1.0.0', '<2.0.0'
+end
+
+if RUBY_VERSION =~ /^2\.[23456789]/
+  gem 'test-unit'
+end

data/gemfiles/gherkin3.gemfile

@@ -0,0 +1,15 @@
+source 'https://rubygems.org'
+
+gemspec :path => "../"
+gem "gherkin", ">= 3.0.0"
+
+# cuke_modeler can play with pretty much any version of these but they all play differently with Ruby
+if RUBY_VERSION =~ /^1\.8/
+  gem 'cucumber', '<1.3.0'
+  gem 'mime-types', '<2.0.0'
+  gem 'rest-client', '<1.7.0'
+end
+
+if RUBY_VERSION =~ /^2\.[23456789]/
+  gem 'test-unit'
+end

data/lib/cuke_modeler/adapters/gherkin_2_adapter.rb

@@ -0,0 +1,146 @@
+module CukeModeler
+  class Gherkin2Adapter
+
+
+    def adapt(parsed_ast)
+      # An AST is just one feature
+      adapt_feature!(parsed_ast.first) if parsed_ast.first
+
+      parsed_ast
+    end
+
+    def adapt_feature!(parsed_feature)
+      # Saving off the original data
+      parsed_feature['cuke_modeler_raw_adapter_output'] = Marshal::load(Marshal.dump(parsed_feature))
+
+      adapt_child_elements!(parsed_feature)
+
+      if parsed_feature['tags']
+        parsed_feature['tags'].each do |tag|
+          adapt_tag!(tag)
+        end
+      end
+    end
+
+    def adapt_child_elements!(parsed_feature)
+      if parsed_feature['elements']
+        parsed_feature['elements'].each do |element|
+          case element['keyword']
+            when 'Background'
+              adapt_background!(element)
+            when 'Scenario'
+              adapt_scenario!(element)
+            when 'Scenario Outline'
+              adapt_outline!(element)
+            else
+              raise("Unknown element keyword: #{element['keyword']}")
+          end
+
+        end
+      end
+    end
+
+    def adapt_background!(parsed_background)
+      # Saving off the original data
+      parsed_background['cuke_modeler_raw_adapter_output'] = Marshal::load(Marshal.dump(parsed_background))
+
+      if parsed_background['steps']
+        parsed_background['steps'].each do |step|
+          adapt_step!(step)
+        end
+      end
+    end
+
+    def adapt_scenario!(parsed_scenario)
+      # Saving off the original data
+      parsed_scenario['cuke_modeler_raw_adapter_output'] = Marshal::load(Marshal.dump(parsed_scenario))
+
+      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)
+        end
+      end
+    end
+
+    def adapt_outline!(parsed_outline)
+      # Saving off the original data
+      parsed_outline['cuke_modeler_raw_adapter_output'] = Marshal::load(Marshal.dump(parsed_outline))
+
+      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)
+        end
+      end
+
+      if parsed_outline['examples']
+        parsed_outline['examples'].each do |example|
+          adapt_example!(example)
+        end
+      end
+    end
+
+    def adapt_example!(parsed_example)
+      # Saving off the original data
+      parsed_example['cuke_modeler_raw_adapter_output'] = Marshal::load(Marshal.dump(parsed_example))
+
+      parsed_example['rows'].each do |row|
+        adapt_table_row!(row)
+      end
+
+      if parsed_example['tags']
+        parsed_example['tags'].each do |tag|
+          adapt_tag!(tag)
+        end
+      end
+    end
+
+    def adapt_tag!(parsed_tag)
+      # Saving off the original data
+      parsed_tag['cuke_modeler_raw_adapter_output'] = Marshal::load(Marshal.dump(parsed_tag))
+    end
+
+    def adapt_step!(parsed_step)
+      # Saving off the original data
+      parsed_step['cuke_modeler_raw_adapter_output'] = Marshal::load(Marshal.dump(parsed_step))
+
+      adapt_doc_string!(parsed_step['doc_string']) if parsed_step['doc_string']
+
+      if parsed_step['rows']
+        parsed_step['rows'] = {'rows' => parsed_step['rows']}
+        adapt_step_table!(parsed_step['rows'])
+      end
+    end
+
+    def adapt_doc_string!(parsed_doc_string)
+      # Saving off the original data
+      parsed_doc_string['cuke_modeler_raw_adapter_output'] = Marshal::load(Marshal.dump(parsed_doc_string))
+    end
+
+    def adapt_step_table!(parsed_step_table)
+      # Saving off the original data
+      parsed_step_table['cuke_modeler_raw_adapter_output'] = Marshal::load(Marshal.dump(parsed_step_table['rows']))
+
+      parsed_step_table['rows'].each do |row|
+        adapt_table_row!(row)
+      end
+    end
+
+    def adapt_table_row!(parsed_table_row)
+      # Saving off the original data
+      parsed_table_row['cuke_modeler_raw_adapter_output'] = Marshal::load(Marshal.dump(parsed_table_row))
+    end
+
+  end
+end

data/lib/cuke_modeler/adapters/gherkin_3_adapter.rb

@@ -0,0 +1,206 @@
+module CukeModeler
+  class Gherkin3Adapter
+
+
+    def adapt(parsed_ast)
+      # An AST is just one feature
+      adapt_feature!(parsed_ast)
+
+      [parsed_ast]
+    end
+
+    def adapt_feature!(parsed_feature)
+      # Saving off the original data
+      parsed_feature['cuke_modeler_raw_adapter_output'] = Marshal::load(Marshal.dump(parsed_feature))
+
+      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)
+      parsed_feature['elements'].concat(parsed_feature.delete(:scenarioDefinitions))
+      parsed_feature['elements'] << parsed_feature.delete(:background) if parsed_feature[:background]
+
+      parsed_feature['tags'] = []
+      parsed_feature[:tags].each do |tag|
+        adapt_tag!(tag)
+      end
+      parsed_feature['tags'].concat(parsed_feature.delete(:tags))
+    end
+
+    def adapt_child_elements!(parsed_feature)
+      adapt_background!(parsed_feature[:background]) if parsed_feature[:background]
+      adapt_tests!(parsed_feature)
+    end
+
+    def adapt_background!(parsed_background)
+      # Saving off the original data
+      parsed_background['cuke_modeler_raw_adapter_output'] = Marshal::load(Marshal.dump(parsed_background))
+
+      parsed_background['keyword'] = parsed_background.delete(:type).to_s
+      parsed_background['name'] = parsed_background.delete(:name)
+      parsed_background['description'] = parsed_background.delete(:description) || ''
+      parsed_background['line'] = parsed_background.delete(:location)[:line]
+
+      parsed_background['steps'] = []
+      parsed_background[:steps].each do |step|
+        adapt_step!(step)
+      end
+      parsed_background['steps'].concat(parsed_background.delete(:steps))
+    end
+
+    def adapt_tests!(parsed_feature)
+      parsed_feature[:scenarioDefinitions].each do |test|
+        adapt_test!(test)
+      end
+    end
+
+    def adapt_test!(parsed_test)
+      # Saving off the original data
+      parsed_test['cuke_modeler_raw_adapter_output'] = Marshal::load(Marshal.dump(parsed_test))
+
+      parsed_test['keyword'] = parsed_test.delete(:type).to_s
+
+      case parsed_test['keyword']
+        when 'Scenario'
+          adapt_scenario!(parsed_test)
+        when 'ScenarioOutline'
+          parsed_test['keyword'] = 'Scenario Outline'
+          adapt_outline!(parsed_test)
+        else
+          raise(ArgumentError, "Unknown test type: #{parsed_test['keyword']}")
+      end
+    end
+
+    def adapt_scenario!(parsed_test)
+      parsed_test['name'] = parsed_test.delete(:name)
+      parsed_test['description'] = parsed_test.delete(:description) || ''
+      parsed_test['line'] = parsed_test.delete(:location)[:line]
+
+      parsed_test['tags'] = []
+      parsed_test[:tags].each do |tag|
+        adapt_tag!(tag)
+      end
+      parsed_test['tags'].concat(parsed_test.delete(:tags))
+
+      parsed_test['steps'] = []
+      parsed_test[:steps].each do |step|
+        adapt_step!(step)
+      end
+      parsed_test['steps'].concat(parsed_test.delete(:steps))
+    end
+
+    def adapt_outline!(parsed_test)
+      parsed_test['name'] = parsed_test.delete(:name)
+      parsed_test['description'] = parsed_test.delete(:description) || ''
+      parsed_test['line'] = parsed_test.delete(:location)[:line]
+
+      parsed_test['tags'] = []
+      parsed_test[:tags].each do |tag|
+        adapt_tag!(tag)
+      end
+      parsed_test['tags'].concat(parsed_test.delete(:tags))
+
+      parsed_test['steps'] = []
+      parsed_test[:steps].each do |step|
+        adapt_step!(step)
+      end
+      parsed_test['steps'].concat(parsed_test.delete(:steps))
+
+      parsed_test['examples'] = []
+      parsed_test[:examples].each do |step|
+        adapt_example!(step)
+      end
+      parsed_test['examples'].concat(parsed_test.delete(:examples))
+    end
+
+    def adapt_example!(parsed_example)
+      # Saving off the original data
+      parsed_example['cuke_modeler_raw_adapter_output'] = Marshal::load(Marshal.dump(parsed_example))
+
+      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'] = []
+      parsed_example['rows'] << adapt_table_row!(parsed_example.delete(:tableHeader))
+
+      parsed_example[:tableBody].each do |row|
+        adapt_table_row!(row)
+      end
+      parsed_example['rows'].concat(parsed_example.delete(:tableBody))
+
+      parsed_example['tags'] = []
+      parsed_example[:tags].each do |tag|
+        adapt_tag!(tag)
+      end
+      parsed_example['tags'].concat(parsed_example.delete(:tags))
+    end
+
+    def adapt_tag!(parsed_tag)
+      # Saving off the original data
+      parsed_tag['cuke_modeler_raw_adapter_output'] = Marshal::load(Marshal.dump(parsed_tag))
+
+      parsed_tag['name'] = parsed_tag.delete(:name)
+      parsed_tag['line'] = parsed_tag.delete(:location)[:line]
+    end
+
+    def adapt_step!(parsed_step)
+      # Saving off the original data
+      parsed_step['cuke_modeler_raw_adapter_output'] = Marshal::load(Marshal.dump(parsed_step))
+
+      parsed_step['keyword'] = parsed_step.delete(:keyword)
+      parsed_step['name'] = parsed_step.delete(:text)
+      parsed_step['line'] = parsed_step.delete(:location)[:line]
+
+
+      step_argument = parsed_step[:argument]
+
+      if step_argument
+        case step_argument[:type]
+          when :DocString
+            adapt_doc_string!(step_argument)
+            parsed_step['doc_string'] = parsed_step.delete(:argument)
+          when :DataTable
+            adapt_step_table!(step_argument)
+            parsed_step['rows'] = parsed_step.delete(:argument)
+          else
+            raise(ArgumentError, "Unknown step argument type: #{step_argument[:type]}")
+        end
+      end
+    end
+
+    def adapt_doc_string!(parsed_doc_string)
+      # Saving off the original data
+      parsed_doc_string['cuke_modeler_raw_adapter_output'] = 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(:contentType)
+    end
+
+    def adapt_step_table!(parsed_step_table)
+      # Saving off the original data
+      parsed_step_table['cuke_modeler_raw_adapter_output'] = Marshal::load(Marshal.dump(parsed_step_table))
+
+      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))
+    end
+
+    def adapt_table_row!(parsed_table_row)
+      # Saving off the original data
+      parsed_table_row['cuke_modeler_raw_adapter_output'] = Marshal::load(Marshal.dump(parsed_table_row))
+
+      parsed_table_row['line'] = parsed_table_row.delete(:location)[:line]
+
+      parsed_table_row['cells'] = parsed_table_row.delete(:cells).collect { |cell| cell[:value] }
+
+
+      parsed_table_row
+    end
+
+  end
+end

data/lib/cuke_modeler/parsing.rb

@@ -1,32 +1,73 @@
-require 'stringio'
-require 'gherkin/formatter/json_formatter'
-require 'gherkin'
-require 'json'
-require 'multi_json'
+# The 'gherkin' gem loads differently depending across versions. Try the old one first and then the new one
+begin
+  require 'gherkin'
+rescue LoadError => e
+  require 'gherkin/parser'
+end
 
-module CukeModeler
+# Parsing will be with an 'adapter' appropriate to the version of the 'gherkin' gem that has been activated
+if Gem.loaded_specs['gherkin'].version.version[/^3/]
 
-  # A module providing source text parsing functionality.
+  require 'gherkin/parser'
+  require 'cuke_modeler/adapters/gherkin_3_adapter'
 
-  module Parsing
 
-    class << self
+  module CukeModeler
 
-      # Parses the Cucumber feature given in *source_text* and returns an array
-      # containing the hash representation of its logical structure.
-      def parse_text(source_text)
-        raise(ArgumentError, "Cannot parse #{source_text.class} objects. Strings only.") unless source_text.is_a?(String)
+    module Parsing
+      class << self
 
-        io = StringIO.new
-        formatter = Gherkin::Formatter::JSONFormatter.new(io)
-        parser = Gherkin::Parser::Parser.new(formatter)
-        parser.parse(source_text, 'fake_file.txt', 0)
-        formatter.done
+        def parse_text(source_text)
+          raise(ArgumentError, "Cannot parse #{source_text.class} objects. Strings only.") unless source_text.is_a?(String)
 
-        MultiJson.load(io.string)
-      end
+          parsed_result = Gherkin::Parser.new.parse(source_text)
+          adapted_result = CukeModeler::Gherkin3Adapter.new.adapt(parsed_result)
 
+          adapted_result
+        end
+      end
     end
+  end
+
+else
+
+  require 'stringio'
+  require 'gherkin/formatter/json_formatter'
+  require 'gherkin'
+  require 'json'
+  require 'multi_json'
+  require 'cuke_modeler/adapters/gherkin_2_adapter'
+
+
+  module CukeModeler
+
+    # A module providing source text parsing functionality.
+
+    module Parsing
 
+      class << self
+
+        # Parses the Cucumber feature given in *source_text* and returns an array
+        # containing the hash representation of its logical structure.
+        def parse_text(source_text)
+          raise(ArgumentError, "Cannot parse #{source_text.class} objects. Strings only.") unless source_text.is_a?(String)
+
+          io = StringIO.new
+          formatter = Gherkin::Formatter::JSONFormatter.new(io)
+          parser = Gherkin::Parser::Parser.new(formatter)
+          parser.parse(source_text, 'fake_file.txt', 0)
+          formatter.done
+
+
+          parsed_result = MultiJson.load(io.string)
+          adapted_result = CukeModeler::Gherkin2Adapter.new.adapt(parsed_result)
+
+          adapted_result
+        end
+
+      end
+
+    end
   end
+
 end