stefl-cucumber 0.10.1

data/lib/cucumber/js_support/js_snippets.rb

@@ -0,0 +1,27 @@
+module Cucumber
+  module JsSupport
+    module JsSnippets
+      PARAM_PATTERN = /"([^"]*)"/
+      ESCAPED_PARAM_PATTERN = '"([^\\"]*)"'
+
+      def snippet_text(code_keyword, step_name, multiline_arg_class)
+        escaped = Regexp.escape(step_name).gsub('\ ', ' ').gsub('/', '\/')
+        escaped = escaped.gsub(PARAM_PATTERN, ESCAPED_PARAM_PATTERN)
+
+        n = 0
+        block_args = escaped.scan(ESCAPED_PARAM_PATTERN).map do |a|
+          n += 1
+          "arg#{n}"
+        end
+        block_args << multiline_arg_class.default_arg_name unless multiline_arg_class.nil?
+        block_arg_string = block_args.empty? ? "" : "#{block_args.join(", ")}"
+        multiline_class_comment = ""
+        if(multiline_arg_class == Ast::Table)
+          multiline_class_comment = "//#{multiline_arg_class.default_arg_name} is a #{multiline_arg_class.to_s}\n"
+        end
+
+        "#{code_keyword}(/^#{escaped}$/, function(#{block_arg_string}){\n  #{multiline_class_comment}  //express the regexp above with the code you wish you had\n});"
+      end
+    end
+  end
+end

data/lib/cucumber/language_support.rb

@@ -0,0 +1,30 @@
+module Cucumber
+  # This module defines the API for programming language support in Cucumber.
+  # While Cucumber itself is written in Ruby, any programming language can
+  # be supported by implementing this API.
+  #
+  # For the sake of illustration we'll consider an imaginary language called
+  # _why. _why files have the .why extension, so we need to put support for
+  # this language in the <tt>Cucumber::WhySupport::WhyLanguage</tt>. This
+  # class must be defined in a file called <tt>cucumber/why_support/why_language.rb</tt>
+  # and be available on Ruby's <tt>$LOAD_PATH</tt>:
+  #
+  #   module Cucumber
+  #     module WhySupport
+  #       class WhyLanguage
+  #
+  #         # Uses whatever available language bridge to load
+  #         # +why_file+ and returns an Array of StepDefinition.
+  #         def load_code_file(why_file)
+  #         end
+  #       end
+  #     end
+  #   end
+  #
+  # Each language implementation manages its own hooks, and must execute them
+  # at appropriate times.
+  #   
+  #
+  module LanguageSupport
+  end
+end

data/lib/cucumber/language_support/language_methods.rb

@@ -0,0 +1,129 @@
+require 'cucumber/step_match'
+require 'cucumber/step_definition_light'
+
+module Cucumber
+  module LanguageSupport
+    module LanguageMethods
+      def create_step_match(step_definition, step_name, name_to_report, step_arguments)
+        StepMatch.new(step_definition, step_name, name_to_report, step_arguments)
+      end
+
+      def around(scenario)
+        execute_around(scenario) do
+          yield
+        end
+      end
+
+      def before(scenario)
+        begin_scenario(scenario)
+        execute_before(scenario)
+      end
+
+      def after(scenario)
+        execute_after(scenario)
+        end_scenario
+      end
+
+      def after_configuration(configuration)
+        hooks[:after_configuration].each do |hook|
+          hook.invoke('AfterConfiguration', configuration)
+        end
+      end
+
+      def execute_after_step(scenario)
+        hooks_for(:after_step, scenario).each do |hook|
+          invoke(hook, 'AfterStep', scenario, false)
+        end
+      end
+
+      def execute_transforms(args)
+        args.map do |arg|
+          matching_transform = transforms.detect {|transform| transform.match(arg) }
+          matching_transform ? matching_transform.invoke(arg) : arg
+        end
+      end
+
+      def add_hook(phase, hook)
+        hooks[phase.to_sym] << hook
+        hook
+      end
+
+      def clear_hooks
+        @hooks = nil
+      end
+
+      def add_transform(transform)
+        transforms.unshift transform
+        transform
+      end
+
+      def hooks_for(phase, scenario) #:nodoc:
+        hooks[phase.to_sym].select{|hook| scenario.accept_hook?(hook)}
+      end
+
+      def unmatched_step_definitions
+        available_step_definition_hash.keys - invoked_step_definition_hash.keys
+      end
+
+      def available_step_definition(regexp_source, file_colon_line)
+        available_step_definition_hash[StepDefinitionLight.new(regexp_source, file_colon_line)] = nil
+      end
+
+      def invoked_step_definition(regexp_source, file_colon_line)
+        invoked_step_definition_hash[StepDefinitionLight.new(regexp_source, file_colon_line)] = nil
+      end
+
+      private
+
+      def available_step_definition_hash
+        @available_step_definition_hash ||= {}
+      end
+
+      def invoked_step_definition_hash
+        @invoked_step_definition_hash ||= {}
+      end
+
+      def hooks
+        @hooks ||= Hash.new{|h,k| h[k] = []}
+      end
+
+      def transforms
+        @transforms ||= []
+      end
+
+      def execute_around(scenario, &block)
+        hooks_for(:around, scenario).reverse.inject(block) do |blk, hook|
+          proc do
+            invoke(hook, 'Around', scenario, true) do
+              blk.call(scenario)
+            end
+          end
+        end.call
+      end
+
+      def execute_before(scenario)
+        hooks_for(:before, scenario).each do |hook|
+          invoke(hook, 'Before', scenario, true)
+        end
+      end
+
+      def execute_after(scenario)
+        hooks_for(:after, scenario).reverse_each do |hook|
+          invoke(hook, 'After', scenario, true)
+        end
+      end
+
+      def invoke(hook, location, scenario, exception_fails_scenario, &block)
+        begin
+          hook.invoke(location, scenario, &block)
+        rescue Exception => exception
+          if exception_fails_scenario
+            scenario.fail!(exception)
+          else
+            raise
+          end
+        end
+      end
+    end
+  end
+end

data/lib/cucumber/parser.rb

@@ -0,0 +1,2 @@
+require 'cucumber/platform'
+require 'cucumber/ast'

data/lib/cucumber/parser/gherkin_builder.rb

@@ -0,0 +1,130 @@
+require 'cucumber/ast'
+require 'gherkin/rubify'
+
+module Cucumber
+  module Parser
+    # This class conforms to the Gherkin event API and builds the
+    # "legacy" AST. It will be replaced later when we have a new "clean"
+    # AST.
+    class GherkinBuilder
+      include Gherkin::Rubify
+
+      def ast
+        @feature || @multiline_arg
+      end
+
+      def feature(feature)
+        @feature = Ast::Feature.new(
+          nil, 
+          Ast::Comment.new(feature.comments.map{|comment| comment.value}.join("\n")), 
+          Ast::Tags.new(nil, feature.tags.map{|tag| tag.name}),
+          feature.keyword,
+          legacy_name_for(feature.name, feature.description),
+          []
+        )
+        @feature.gherkin_statement(feature)
+        @feature
+      end
+
+      def background(background)
+        @background = Ast::Background.new(
+          Ast::Comment.new(background.comments.map{|comment| comment.value}.join("\n")), 
+          background.line, 
+          background.keyword, 
+          legacy_name_for(background.name, background.description), 
+          steps=[]
+        )
+        @feature.background = @background
+        @background.feature = @feature
+        @step_container = @background
+        @background.gherkin_statement(background)
+      end
+
+      def scenario(statement)
+        scenario = Ast::Scenario.new(
+          @background, 
+          Ast::Comment.new(statement.comments.map{|comment| comment.value}.join("\n")), 
+          Ast::Tags.new(nil, statement.tags.map{|tag| tag.name}), 
+          statement.line, 
+          statement.keyword, 
+          legacy_name_for(statement.name, statement.description), 
+          steps=[]
+        )
+        @feature.add_feature_element(scenario)
+        @background.feature_elements << scenario if @background
+        @step_container = scenario
+        scenario.gherkin_statement(statement)
+      end
+
+      def scenario_outline(statement)
+        scenario_outline = Ast::ScenarioOutline.new(
+          @background, 
+          Ast::Comment.new(statement.comments.map{|comment| comment.value}.join("\n")), 
+          Ast::Tags.new(nil, statement.tags.map{|tag| tag.name}), 
+          statement.line, 
+          statement.keyword, 
+          legacy_name_for(statement.name, statement.description), 
+          steps=[],
+          example_sections=[]
+        )
+        @feature.add_feature_element(scenario_outline)
+        if @background
+          @background = @background.dup
+          @background.feature_elements << scenario_outline
+        end
+        @step_container = scenario_outline
+        scenario_outline.gherkin_statement(statement)
+      end
+
+      def examples(examples)
+        examples_fields = [
+          Ast::Comment.new(examples.comments.map{|comment| comment.value}.join("\n")), 
+          examples.line, 
+          examples.keyword, 
+          legacy_name_for(examples.name, examples.description), 
+          matrix(examples.rows)
+        ]
+        @step_container.add_examples(examples_fields, examples)
+      end
+
+      def step(step)
+        @table_owner = Ast::Step.new(step.line, step.keyword, step.name)
+        @table_owner.gherkin_statement(step)
+        multiline_arg = rubify(step.multiline_arg)
+        case(multiline_arg)
+        when Gherkin::Formatter::Model::PyString
+          @table_owner.multiline_arg = Ast::PyString.new(multiline_arg.value)
+        when Array
+          @table_owner.multiline_arg = Ast::Table.new(matrix(multiline_arg))
+        end
+        @step_container.add_step(@table_owner)
+      end
+
+      def eof
+      end
+
+      def syntax_error(state, event, legal_events, line)
+        # raise "SYNTAX ERROR"
+      end
+      
+    private
+    
+      def legacy_name_for(name, description)
+        s = name
+        s += "\n#{description}" if description != ""
+        s
+      end
+
+      def matrix(gherkin_table)
+        gherkin_table.map do |gherkin_row|
+          row = gherkin_row.cells
+          class << row
+            attr_accessor :line
+          end
+          row.line = gherkin_row.line
+          row
+        end
+      end
+    end
+  end
+end

data/lib/cucumber/platform.rb

@@ -0,0 +1,29 @@
+# Detect the platform we're running on so we can tweak behaviour
+# in various places.
+require 'rbconfig'
+
+module Cucumber
+unless defined?(Cucumber::VERSION)
+  VERSION       = '0.10.0'
+  BINARY        = File.expand_path(File.dirname(__FILE__) + '/../../bin/cucumber')
+  LIBDIR        = File.expand_path(File.dirname(__FILE__) + '/../../lib')
+  JRUBY         = defined?(JRUBY_VERSION)
+  IRONRUBY      = defined?(RUBY_ENGINE) && RUBY_ENGINE == "ironruby"
+  WINDOWS       = RbConfig::CONFIG['host_os'] =~ /mswin|mingw/
+  OS_X          = RbConfig::CONFIG['host_os'] =~ /darwin/
+  WINDOWS_MRI   = WINDOWS && !JRUBY && !IRONRUBY
+  RAILS         = defined?(Rails)
+  RUBY_BINARY   = File.join(RbConfig::CONFIG['bindir'], RbConfig::CONFIG['ruby_install_name'])
+  RUBY_1_9      = RUBY_VERSION =~ /^1\.9/
+  RUBY_1_8_7    = RUBY_VERSION =~ /^1\.8\.7/
+
+  class << self
+    attr_accessor :use_full_backtrace
+
+    def file_mode(m) #:nodoc:
+      RUBY_1_9 ? "#{m}:UTF-8" : m
+    end
+  end
+  self.use_full_backtrace = false
+end
+end

data/lib/cucumber/py_support/py_dsl.py

@@ -0,0 +1,10 @@
+import py_language
+
+class Given(object):
+  def __init__(self, regexp):
+    self.regexp = regexp
+    
+  def __call__(self, f):
+    py_language.register_step_def(self.regexp, f)
+    return f
+  

data/lib/cucumber/py_support/py_language.py

@@ -0,0 +1,10 @@
+import py_dsl
+
+step_defs = {}
+
+def register_step_def(regexp, f):
+  print "Got a step def: ", regexp
+  step_defs[regexp] = f
+  
+def step_matches(step_name, name_to_report):
+  print "WTF: " + step_name

data/lib/cucumber/py_support/py_language.rb

@@ -0,0 +1,84 @@
+require 'rubypython'
+
+module Cucumber
+  module PySupport
+    class PyLanguage
+      include LanguageSupport::LanguageMethods
+
+      def initialize(step_mother)
+        @step_def_files = []
+        #
+        # @python_path = ENV['PYTHONPATH'] ? ENV['PYTHONPATH'].split(':') : []
+        # add_to_python_path(File.dirname(__FILE__))
+        #
+        # RubyPython.start
+        # at_exit{RubyPython.stop}
+        #
+        # import(File.dirname(__FILE__) + '/py_language.py')
+      end
+
+      def load_code_file(py_file)
+        @step_def_files << py_file
+      end
+
+      def alias_adverbs(adverbs)
+      end
+
+      def step_definitions_for(py_file)
+        mod = import(py_file)
+      end
+
+      def snippet_text(code_keyword, step_name, multiline_arg_class)
+        "python snippet: #{code_keyword}, #{step_name}"
+      end
+
+      def begin_scenario(scenario)
+        @python_path = []
+        add_to_python_path(File.dirname(__FILE__))
+        @step_def_files.each{|f| add_to_python_path(File.dirname(f))}
+
+        RubyPython.start
+
+        @delegate = import(File.dirname(__FILE__) + '/py_language.py')
+        @step_def_files.each{|f| import(f)}
+      end
+
+      def end_scenario
+      end
+
+      def step_matches(step_name, name_to_report)
+        @delegate.step_matches(step_name, name_to_report)
+      end
+
+      private
+
+      def import(path)
+        modname = File.basename(path)[0...-File.extname(path).length]
+        begin
+          mod = RubyPython.import(modname)
+        rescue PythonError => e
+#          e.message << "Couldn't load #{path}\nConsider adding #{File.expand_path(File.dirname(path))} to your PYTHONPATH"
+          raise e
+        end
+      end
+
+      def add_to_python_path(dir)
+        dir = File.expand_path(dir)
+        @python_path.unshift(dir)
+        @python_path.uniq!
+        ENV['PYTHONPATH'] = @python_path.join(':')
+      end
+    end
+  end
+end
+
+class String #:nodoc:
+  # RubyPython incorrectly to expects String#end_with? to exist.
+  unless defined? end_with? # 1.9
+    def end_with?(str) #:nodoc:
+      str = str.to_str
+      tail = self[-str.length, str.length]
+      tail == str
+    end
+  end
+end