cucumber2rspec 0.1.0

data/bin/cucumber2rspec

@@ -0,0 +1,20 @@
+#! /usr/bin/env ruby
+require File.dirname(__FILE__) + '/../lib/cucumber2rspec'
+require 'logger'
+Cucumber2RSpec.logger = Logger.new(STDERR)
+Cucumber2RSpec.logger.level = Logger::DEBUG
+
+unless ARGV.length >= 2
+  puts "Usage: cucumber2rspec dir/with/step_definitions feature1 feature2 ..."
+  exit
+end
+
+steps_dir = ARGV.shift
+Cucumber2RSpec.log { "Loading steps ..." }
+Dir[File.join(steps_dir, '**', '*_steps.rb')].each {|step_file| require step_file }
+
+feature = ARGV.shift
+Cucumber2RSpec.log { "Feature to convert: #{ File.basename(feature) }" }
+puts Cucumber2RSpec.translate_file feature
+
+# vim:set ft=ruby:

data/lib/cucumber2rspec.rb

@@ -0,0 +1,87 @@
+$LOAD_PATH.unshift File.dirname(__FILE__)
+
+# Last tested with cucumber (0.3.11, 0.3.3)
+#
+# Note: String#indent comes from cucumber
+
+require 'rubygems'
+require 'parse_tree'
+require 'parse_tree_extensions'
+require 'ruby2ruby'
+require 'cucumber'
+
+$step_match = method(:step_match)
+
+# ...
+module Cucumber2RSpec
+
+  class << self
+    attr_accessor :logger
+  end
+
+  def self.log &block
+    logger.debug(&block) if logger
+  end
+
+  def self.parser
+    Cucumber.load_language('en')
+    @parser ||= Cucumber::Parser::FeatureParser.new
+  end
+
+  def self.step_match text
+    $step_match.call(text)
+  end
+
+  def self.translate feature_text
+    Cucumber2RSpec::Feature.new(feature_text).code
+  end
+
+  def self.translate_file filepath
+    Cucumber2RSpec.log { "translate_file(#{filepath.inspect})" }
+    translate File.read(filepath)
+  end
+
+  def self.replace_in_sexp sexp, to_replace, replace_with
+    while sexp.include?(to_replace)
+      index = sexp.index(to_replace)
+      sexp.delete_at index
+      sexp.insert    index, replace_with
+    end
+    
+    sexp.each do|obj|
+      replace_in_sexp(obj, to_replace, replace_with) if obj.is_a?(Sexp)
+    end
+
+    sexp
+  end
+
+  def self.block_variable_names a_proc
+    sexp               = a_proc.to_sexp
+    local_assignments  = []
+
+    # this is where the variables hang out ...
+    if sexp[2] and sexp[2].is_a?(Sexp)
+      
+      # there's only 1 local assigned variable
+      if sexp[2][0] == :lasgn
+        local_assignments << sexp[2][1]
+        
+      # there's an array of locally assigned variables
+      elsif sexp[2][0] == :masgn and sexp[2][1][0] == :array # mass assignment using an array
+        array_of_variables = a_proc.to_sexp[2][1]
+        the_type           = array_of_variables.shift
+        array_of_variables.each do |sub_sexp|
+          local_assignments << sub_sexp[1] if sub_sexp[0] == :lasgn
+        end
+      end
+    end
+
+    local_assignments
+  end
+
+end
+
+require 'cucumber2rspec/feature'
+require 'cucumber2rspec/background'
+require 'cucumber2rspec/scenario'
+require 'cucumber2rspec/step'

data/lib/cucumber2rspec/background.rb

@@ -0,0 +1,29 @@
+module Cucumber2RSpec #:nodoc:
+
+  # ...
+  class Background
+    attr_reader :feature, :_background
+
+    def initialize feature, cucumber_ast_background
+      @feature   = feature
+      @_background = cucumber_ast_background # Cucumber::Ast::Background
+    end
+
+    def steps
+      _background.instance_variable_get('@steps').map {|step| Step.new(self, step) }
+    end
+
+    def code_without_block
+      Step.code_for_steps(steps)
+    end
+
+    def code
+      Cucumber2RSpec.log { '  Background' }
+      the_code = "  before do\n"
+      the_code << code_without_block.sub(/\n$/, '') # kill the last newline
+      the_code << '  end'
+    end
+
+  end
+
+end

data/lib/cucumber2rspec/feature.rb

@@ -0,0 +1,35 @@
+module Cucumber2RSpec #:nodoc:
+
+  # ...
+  class Feature
+    attr_reader :raw, :name, :_feature
+
+    def initialize raw_feature_text
+      @raw      = raw_feature_text
+      @_feature = Cucumber2RSpec.parser.parse_or_fail(raw) # Cucumber::Ast::Feature
+    end
+
+    def name
+      # @_feature.name returns "Feature: Foo\n  In order to ..."
+      match = _feature.name.match(/Feature: ([\w ]+)/)
+      match[1] if match
+    end
+
+    def background
+      _background = _feature.instance_variable_get('@background')
+      Background.new self, _background if _background
+    end
+
+    def scenarios
+      _feature.instance_variable_get('@feature_elements').map {|scenario| Scenario.new(self, scenario) }
+    end
+
+    def code
+      Cucumber2RSpec.log { name }
+      the_code = 'describe ' + name.inspect + ' do' + "\n\n"
+      the_code << background.code + "\n\n" if background
+      scenarios.each {|scenario| the_code << scenario.code + "\n\n" }
+      the_code << "end"
+    end
+  end
+end

data/lib/cucumber2rspec/scenario.rb

@@ -0,0 +1,38 @@
+module Cucumber2RSpec #:nodoc:
+
+  # ...
+  class Scenario
+    attr_reader :feature, :_scenario
+
+    def initialize feature, cucumber_ast_scenario
+      @feature   = feature
+      @_scenario = cucumber_ast_scenario # Cucumber::Ast::Scenario
+    end
+
+    def name
+      _scenario.name
+    end
+
+    def steps
+      _scenario.instance_variable_get('@steps').map {|step| Step.new(self, step) }
+    end
+
+    def code_without_block
+      code = Step.code_for_steps(steps)
+
+      if background = feature.background
+        # remove the background code from the scenario
+        code = code.sub background.code_without_block.sub(/\n$/, ''), ''
+      else
+        code
+      end
+    end
+
+    def code
+      Cucumber2RSpec.log { '  ' + name }
+      the_code = '  it ' + name.inspect + " do\n"
+      the_code << code_without_block
+      the_code << '  end'
+    end
+  end
+end

data/lib/cucumber2rspec/step.rb

@@ -0,0 +1,159 @@
+module Cucumber2RSpec #:nodoc:
+
+  # ...
+  class Step
+    attr_reader :scenario, :_step
+
+    def self.code_for_steps steps
+      the_code = ''
+      groups   = {
+        'Given' => [],
+        'When'  => [],
+        'Then'  => []
+      }
+
+      last_keyword = 'Given'
+      steps.each do |step|
+        keyword = (step.keyword == 'And') ? last_keyword : step.keyword
+        groups[keyword] << step.code
+        last_keyword = step.keyword unless step.keyword == 'And'
+      end
+
+      groups['Given'].each {|code| the_code << (code.indent(4) + "\n") }
+      the_code << "\n" if groups['Given'].length > 0
+      
+      groups['When' ].each {|code| the_code << (code.indent(4) + "\n") }
+      the_code << "\n" if groups['When'].length > 0
+
+      groups['Then' ].each {|code| the_code << (code.indent(4) + "\n") }
+      the_code
+    end
+
+    def initialize scenario, cucumber_ast_step_invocation
+      @scenario = scenario
+      @_step    = cucumber_ast_step_invocation # Cucumber::Ast::StepInvocation
+    end
+
+    def keyword
+      _step.respond_to?(:actual_keyword) ? _step.actual_keyword : _step.keyword
+    end
+
+    def table
+      _step.multiline_arg if _step.respond_to?(:multiline_arg)
+    end
+
+    def has_table?
+      !! table
+    end
+
+    def text
+      if has_table?
+        _step.to_sexp[ _step.to_sexp.length - 2 ] # the last argument will be the table!
+      else
+        _step.to_sexp.last
+      end
+    end
+
+    def full_text
+      "#{keyword} #{text}"
+    end
+
+    def _step_definition
+      Cucumber2RSpec.step_match(text).instance_variable_get('@step_definition')
+    end
+
+    def regexp
+      Regexp.new _step_definition.instance_variable_get('@regexp')
+    end
+
+    def raw_variable_names
+      Cucumber2RSpec.block_variable_names(the_proc)
+    end
+
+    def variable_names
+      # if has_table? then we ignore the last block variable (which is the table)
+      variables = raw_variable_names
+      variables.pop if has_table?
+      variables
+    end
+
+    def table_variable_name
+      raw_variable_names.last if has_table?
+    end
+
+    def the_proc
+      _step_definition.instance_variable_get('@proc')
+    end
+
+    def matches
+      return [] if variable_names.empty?
+
+      match = text.match(regexp)
+      if match
+        matches = {}
+        if match.captures.length != variable_names.length
+          raise "Problem getting #{ variable_names.inspect } from #{ text.inspect }."
+        end
+        variable_names.each_with_index do |name, i|
+          matches[name] = match.captures[i]
+        end
+        matches
+      else
+        []
+      end
+    end
+
+    def code
+      Cucumber2RSpec.log { '    ' + text }
+
+      if has_table?
+        # require cucumber and create a local variable defining the cucumber table
+        header = "require 'cucumber'\n"
+        header << "#{table_variable_name} = Cucumber::Ast::Table.new(#{ table.raw.inspect })\n"
+      end
+
+      if variable_names.empty?
+        ruby = the_proc.to_ruby
+
+        if has_table?
+          # get rid of proc { |table| }
+          ruby = ruby.sub(/^proc \{ \|#{table_variable_name}\|\s+/, '').sub(/\s\}$/, '')
+        else
+          # get rid of proc { }
+          ruby = ruby.sub(/^proc \{\s+/, '').sub(/\s\}$/, '')
+        end
+
+      else
+        # TODO replace with the_proc.to_sexp
+        sexp_for_proc = ParseTree.new.process(the_proc.to_ruby) # turn the proc into an Sexp
+        matches.each do |name, value|
+          str = Sexp.new(:str, value)
+
+          # s(:lvar, :var) => s(:str, "dogs")
+          Cucumber2RSpec.replace_in_sexp sexp_for_proc, Sexp.new(:lvar, name), str
+
+          # s(:evstr, s(:str, "dogs")) => s(:str, "dogs")
+          Cucumber2RSpec.replace_in_sexp sexp_for_proc, Sexp.new(:evstr, str), str
+        end
+        ruby = Ruby2Ruby.new.process(sexp_for_proc) # turn it back into ruby
+        if ruby =~ /^proc do/
+          # get rid of the proc do |x| end
+          ruby = ruby.sub(/^proc do \|([\w+, ]+)\|\n  /, '').sub(/\send$/, '')
+        elsif ruby =~ /^proc \{ |/
+          # get rid of proc { |whatever, ...| }
+          ruby = ruby.sub(/^proc \{ \|([^\|]+)\|\s+/, '').sub(/\s\}$/, '')
+        elsif ruby =~ /^proc \{/
+          # get rid of proc { }
+          ruby = ruby.sub(/^proc \{\s+/, '').sub(/\s\}$/, '')
+        else
+          raise "Not sure how to clean up the code for: #{ ruby }"
+        end
+      end
+
+      ruby = header + ruby if has_table?
+
+      # get rid of any spaces after any newlines
+      ruby.gsub(/\n[ ]+/, "\n")
+    end
+  end
+end

metadata

@@ -0,0 +1,108 @@
+--- !ruby/object:Gem::Specification 
+name: cucumber2rspec
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 1
+  - 0
+  version: 0.1.0
+platform: ruby
+authors: 
+- remi
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-03-31 00:00:00 -07:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: cucumber
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        - 3
+        - 11
+        version: 0.3.11
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: ParseTree
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 3
+        - 0
+        - 3
+        version: 3.0.3
+  type: :runtime
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: ruby2ruby
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 1
+        - 2
+        - 2
+        version: 1.2.2
+  type: :runtime
+  version_requirements: *id003
+description: Convert Cucumber features to RSpec
+email: remi@remitaylor.com
+executables: 
+- cucumber2rspec
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/cucumber2rspec/background.rb
+- lib/cucumber2rspec/step.rb
+- lib/cucumber2rspec/scenario.rb
+- lib/cucumber2rspec/feature.rb
+- lib/cucumber2rspec.rb
+- bin/cucumber2rspec
+has_rdoc: true
+homepage: http://github.com/devfu/cucumber2rspec
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.6
+signing_key: 
+specification_version: 3
+summary: Convert Cucumber features to RSpec
+test_files: []
+