cucumber_converter 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: e724f4801bff3904058cfe06e7422f9f08fce8ad
+  data.tar.gz: b1f1c3ed1ec67fb7d6b0ffcc2134c0d34581bb8c
+SHA512:
+  metadata.gz: 70173f93eb47117f642d25e41d05a3d73ffa9fa873776a07d7103f0517ca9800bee3a270e263a2504cc0989e043067266a0712c85f396f4f271a25b2a6fc9cf7
+  data.tar.gz: 66d9aad618734b1925cc531a19e120a5a02178c2bad27425f3e0499bda012be656a613a739dcc61d382fa8e378ecdb21cd3f8aace34ca4fc09250d2d46139e09

data/bin/cucumber_convert

@@ -0,0 +1,3 @@
+#!/usr/bin/env ruby
+
+load File.expand_path('../../lib/cucumber_converter.rb', __FILE__)

data/lib/background.rb

@@ -0,0 +1,12 @@
+class Background
+  include StepContainer
+
+  def initialize(gherkin, step_data)
+    @steps = gherkin[:steps] || []
+    @step_data = step_data
+  end
+
+  def template_path
+    File.expand_path('./templates/background.erb', GEM_PATH)
+  end
+end

data/lib/config.rb

@@ -0,0 +1,17 @@
+module Configuration
+  class << self
+    def default_config
+      {
+        step_path_base: File.expand_path("features/step_definitions", WD),
+        feature_path_base: File.expand_path("features", WD),
+        tags: { "@javascript" => "js: true" }
+      }
+    end
+
+    def config(config_file)
+      OpenStruct.new(default_config.merge(
+        File.exists?(config_file) ? YAML.load_file(config_file) : {}
+      ))
+    end
+  end
+end

data/lib/cucumber_converter.rb

@@ -0,0 +1,20 @@
+require 'setup'
+
+# load all step definitions to be captured
+# having redifined 'Given' in the main object, loading these files in the main scope
+# should call our definition, which has a reference to our step capturer to capture these calls.
+Dir.glob("#{Config.step_path_base}/**/*.rb").each(&method(:load))
+
+# Beep Boop Beep -- now we have code for step definitions
+steps = step_capturer.post_process!
+
+# Write those files!
+step_definitions = StepDefinition.parse_steps(steps, Config.step_path_base)
+FileWriter.write_files(step_definitions)
+
+# convert feature files
+# use gherkin parser to get an object representation of a feature file,
+# and write it in rspec syntax
+feature_files = Dir.glob("#{Config.feature_path_base}/**/*.feature")
+features = Feature.parse_features(feature_files, Gherkin::Parser.new, steps)
+FileWriter.write_files(features)

data/lib/feature.rb

@@ -0,0 +1,51 @@
+class Feature
+  include StepContainer
+
+  attr_accessor :gherkin
+
+  class << self
+    def parse_features(feature_files, parser, steps)
+      feature_files.each_with_object({}) do |filename, memo|
+        gherkin_document = parser.parse(File.read(filename))
+        memo[new_filename(filename)] = new(gherkin_document, steps)
+      end
+    end
+
+    def new_filename(filename)
+      FileWriter
+       .write_path(Config.feature_path_base, "cucumber_to_rspec/features/", WD, filename)
+       .gsub('.feature', '.rb')
+    end
+  end
+
+  def initialize(gherkin, step_data)
+    @gherkin = gherkin
+    @step_data = step_data
+  end
+
+  private
+
+  def feature_name
+    @feature_name ||= gherkin[:feature][:name]
+  end
+
+  def feature_tags
+    tag_parser.format_tags(gherkin[:feature][:tags])
+  end
+
+  def scenarios
+    @scenarios ||= gherkin[:feature][:children].select { |child|
+      child[:type] == :Scenario
+    }.map{ |child| Scenario.new(child, step_data) }
+  end
+
+  def background
+    @background ||= gherkin[:feature][:children].select { |child|
+      child[:type] == :Background
+    }.map{ |child| Background.new(child, step_data) }.first
+  end
+
+  def template_path
+    File.expand_path('./templates/feature.erb', GEM_PATH)
+  end
+end

data/lib/file_writer.rb

@@ -0,0 +1,16 @@
+module FileWriter
+  class << self
+    def write_path(base_path, write_path, wd, filename)
+      File.expand_path(filename.gsub(base_path, File.expand_path(write_path, wd)))
+    end
+
+    def write_file(file_path, file_contents)
+      response = FileUtils.mkdir_p(File.dirname(file_path))
+      File.open(file_path, 'w+') { |f| f.write(file_contents) }
+    end
+
+    def write_files(files)
+      files.each(&method(:write_file))
+    end
+  end
+end

data/lib/given.rb

@@ -0,0 +1,17 @@
+module GivenDefinition
+  # Define Given, Then, When, And to record all step definitions.
+
+  attr_reader :step_capturer
+
+  def set_step_capturer(step_capturer)
+    @step_capturer = step_capturer
+  end
+
+  def Given(regex, &block)
+    step_capturer.capture!(regex, &block)
+  end
+
+  alias Then Given
+  alias And Given
+  alias When Given
+end

data/lib/scenario.rb

@@ -0,0 +1,22 @@
+class Scenario
+  include StepContainer
+
+  attr_accessor :name
+
+  def initialize(gherkin, step_data)
+    @name = gherkin[:name]
+    @steps = gherkin[:steps] || []
+    @tags = gherkin[:tags]
+    @step_data = step_data
+  end
+
+  private
+
+  def scenario_tags
+    tag_parser.format_tags(@tags)
+  end
+
+  def template_path
+    File.expand_path('./templates/scenario.erb', GEM_PATH)
+  end
+end

data/lib/setup.rb

@@ -0,0 +1,24 @@
+require 'fileutils'
+require "ostruct"
+require 'yaml'
+require 'erb'
+require 'gherkin/parser'
+require 'gherkin/pickles/compiler'
+require_relative 'config'
+require_relative 'step_capture'
+require_relative 'file_writer'
+require_relative 'step_container'
+require_relative 'step_definition'
+require_relative 'step_converter'
+require_relative 'feature'
+require_relative 'background'
+require_relative 'scenario'
+require_relative 'tag_parser'
+require 'given'
+
+WD = `pwd`.chomp
+GEM_PATH = File.dirname(File.expand_path(__FILE__))
+Config = Configuration.config(File.expand_path('.cucumber_converter.yml', WD))
+
+include GivenDefinition
+set_step_capturer(StepCapturer.new)

data/lib/step_capture.rb

@@ -0,0 +1,17 @@
+class StepCapturer
+  attr_accessor :step_definitions
+
+  def initialize
+    @step_definitions = []
+  end
+
+  def capture!(regex, &block)
+    step_definitions << StepDefinition.new(regex, &block)
+  end
+
+  def post_process!
+    @step_definitions = step_definitions.map do |step|
+      step.process!(step_definitions)
+    end
+  end
+end

data/lib/step_container.rb

@@ -0,0 +1,29 @@
+module StepContainer
+  attr_accessor :steps, :step_data
+
+  def to_s
+    template.result(binding)
+  end
+
+  private
+
+  def tag_parser
+    @tag_parser ||= TagParser.new
+  end
+
+  def step_converter
+    @step_converter ||= StepConverter.new
+  end
+
+  def parse_step(step)
+    step_converter.convert(step[:text], step_data)
+  end
+
+  def parsed_steps
+    steps.map(&method(:parse_step))
+  end
+
+  def template
+    ERB.new(File.read(template_path), nil, '->')
+  end
+end

data/lib/step_converter.rb

@@ -0,0 +1,17 @@
+class StepConverter
+  def convert(step_line, step_definitions)
+    matched = matched_step(step_line, step_definitions)
+    if matched
+      arguments = matched.regex.match(step_line)[1..-1]
+      "#{matched.method_name}(#{arguments.map(&:inspect).join(", ")})"
+    else
+      "# #{step_line} -- no method matched"
+    end
+  end
+
+  def matched_step(step_line, step_definitions)
+    step_definitions.find do |step_definition|
+      step_definition.regex.match(step_line)
+    end
+  end
+end

data/lib/step_definition.rb

@@ -0,0 +1,96 @@
+require 'method_source'
+
+class StepDefinition
+  WRITE_PATH = "cucumber_to_rspec/step_definitions/"
+
+  class << self
+    def parse_steps(steps, base_path)
+      self.steps_by_file(steps).each_with_object({}) do |(filename, file_steps), memo|
+        memo[self.new_file_path(filename, base_path)] = self.render_template(file_steps)
+      end
+    end
+
+    def steps_by_file(steps)
+      steps.group_by(&:location)
+    end
+
+    def new_file_path(filename, base_path)
+      FileWriter.write_path(base_path, WRITE_PATH, WD, filename)
+    end
+
+    def render_template(file_steps)
+      self.template.result(binding)
+    end
+
+    def template
+      ERB.new(File.read(self.template_path), nil, '->')
+    end
+
+    def template_path
+      File.expand_path('./templates/step_definitions_file.erb', GEM_PATH)
+    end
+  end
+
+  attr_accessor :regex, :block, :location, :method_name, :processed_code
+
+  def step_converter
+    @step_converter ||= StepConverter.new
+  end
+
+  def initialize(regex, &block)
+    @regex = regex
+    @method_name = method_name_from_regex(regex)
+    @block = block
+    @location = block.source_location.first
+  end
+
+  def method_name_from_regex(regex)
+    regex
+      .inspect[1..-2]
+      .gsub(/\s/,"_")
+      .gsub(/\W|\d/,"")
+      .gsub(/_$/,"")
+      .gsub(/_+/,"_")
+      .downcase
+  end
+
+  def to_s
+    template.result(binding)
+  end
+
+  def template_path
+    File.expand_path('./templates/step_definition.erb', GEM_PATH)
+  end
+
+  def template
+    ERB.new(File.read(template_path), nil, '->')
+  end
+
+  def block_source
+    @block_source ||= block.source
+  end
+
+  def method_definition
+    return @method_definition if @method_definition
+    match = block_source.split("\n").first.match(/(?:And|When|Then|Given)\(.*\)[\s]do[\s]?(?:\|(.*)\|)?/)
+    @method_definition = match ? method_name + ('(%s)' % match[1]) : method_name
+  end
+
+  def method_body
+    @method_body || raise("Method not processed")
+  end
+
+  # this is specifically looking to references to other steps, by way of the 'step' call. If it finds these lines
+  # it will substitute a direct method call, like we do with the features
+  def process!(step_definitions)
+    @method_body = block_source.split("\n")[1..-2].map do |line|
+      step_method_call_match = line.match(/^(\s*)step "(.*)"/)
+      if step_method_call_match
+        step_method_call_match[1] + step_converter.convert(step_method_call_match[2], step_definitions)
+      else
+        line
+      end
+    end
+    return self
+  end
+end

data/lib/tag_parser.rb

@@ -0,0 +1,6 @@
+class TagParser
+  def format_tags(tags)
+    return nil if tags.empty?
+    ", #{tags.map{ |tag| Config.tags[tag[:name]] || tag[:name].tr('@',':') }.join(", ")}"
+  end
+end

data/lib/templates/background.erb

@@ -0,0 +1,5 @@
+before(:each) do
+  <% parsed_steps.each do |step| -%>
+  <%= step %>
+  <% end -%>
+end

data/lib/templates/feature.erb

@@ -0,0 +1,6 @@
+feature "<%= feature_name %>"<%= feature_tags %> do
+  <%= background -%>
+<% scenarios.each do |scenario| %>
+  <%= scenario -%>
+<% end -%>
+end

data/lib/templates/scenario.erb

@@ -0,0 +1,5 @@
+scenario "<%= name %>"<%= scenario_tags %> do
+  <% parsed_steps.each do |step| -%>
+  <%= step %>
+  <% end -%>
+end

data/lib/templates/step_definition.erb

@@ -0,0 +1,5 @@
+def <%= method_definition %>
+<% method_body.each do |line| -%>
+  <%= line %>
+<% end -%>
+  end

data/lib/templates/step_definitions_file.erb

@@ -0,0 +1,5 @@
+module StepDefinitions
+<% file_steps.each do |step| -%>
+  <%= step %>
+<% end -%>
+end

metadata

@@ -0,0 +1,62 @@
+--- !ruby/object:Gem::Specification
+name: cucumber_converter
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Tracy Meade
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2017-07-28 00:00:00.000000000 Z
+dependencies: []
+description: Converts cucumber tests to Rspec Features
+email: meade.tracy@gmail.com
+executables:
+- cucumber_convert
+extensions: []
+extra_rdoc_files: []
+files:
+- bin/cucumber_convert
+- lib/background.rb
+- lib/config.rb
+- lib/cucumber_converter.rb
+- lib/feature.rb
+- lib/file_writer.rb
+- lib/given.rb
+- lib/scenario.rb
+- lib/setup.rb
+- lib/step_capture.rb
+- lib/step_container.rb
+- lib/step_converter.rb
+- lib/step_definition.rb
+- lib/tag_parser.rb
+- lib/templates/background.erb
+- lib/templates/feature.erb
+- lib/templates/scenario.erb
+- lib/templates/step_definition.erb
+- lib/templates/step_definitions_file.erb
+homepage: 
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.5.1
+signing_key: 
+specification_version: 4
+summary: Converts cucumber tests to Rspec Features
+test_files: []