cucumber 1.3.10 → 2.0.0

data/lib/cucumber/js_support/js_language.rb

@@ -1,185 +0,0 @@
-begin
-  require 'v8'
-rescue LoadError
-  gem 'therubyracer', '~> 0.7.1'
-  require 'v8'
-end
-
-require 'cucumber/js_support/js_snippets'
-
-module Cucumber
-  module JsSupport
-
-    def self.argument_safe_string(string)
-      arg_string = string.to_s.gsub(/[']/, '\\\\\'')
-      arg_string.gsub("\n", '\n')
-    end
-
-    class JsWorld
-      def initialize
-        @world = V8::Context.new
-      end
-
-      def execute(js_function, args=[])
-        js_function.call(*args)
-      end
-
-      def method_missing(method_name, *args)
-        @world.send(method_name, *args)
-      end
-    end
-
-    class JsStepDefinition
-      def initialize(js_language, regexp, js_function)
-        @js_language, @regexp, @js_function = js_language, regexp.to_s, js_function
-      end
-
-      def invoke(args)
-        args = @js_language.execute_transforms(args)
-        @js_language.current_world.execute(@js_function, args)
-      end
-
-      def regexp_source
-        @regexp.inspect
-      end
-
-      def arguments_from(step_name)
-        matches = eval_js "#{@regexp}.exec('#{step_name}')"
-        if matches
-          matches.to_a[1..-1].map do |match|
-            JsArg.new(match)
-          end
-        end
-      end
-
-      def file_colon_line
-        # Not possible yet to get file/line of js function with V8/therubyracer
-        ""
-      end
-    end
-
-    class JsHook
-      def initialize(js_language, tag_expressions, js_function)
-        @js_language, @tag_expressions, @js_function = js_language, tag_expressions, js_function
-      end
-
-      def tag_expressions
-        @tag_expressions
-      end
-
-      def invoke(location, scenario)
-        @js_language.current_world.execute(@js_function)
-      end
-    end
-
-    class JsTransform
-      def initialize(js_language, regexp, js_function)
-        @js_language, @regexp, @js_function = js_language, regexp.to_s, js_function
-      end
-
-      def match(arg)
-        arg = JsSupport.argument_safe_string(arg)
-        matches = (eval_js "#{@regexp}.exec('#{arg}');").to_a
-        matches.empty? ? nil : matches[1..-1]
-      end
-
-      def invoke(arg)
-        @js_function.call([arg])
-      end
-    end
-
-    class JsArg
-      def initialize(arg)
-        @arg = arg
-      end
-
-      def val
-        @arg
-      end
-
-      def offset
-      end
-    end
-
-    class JsLanguage
-      include LanguageSupport::LanguageMethods
-      include JsSnippets
-
-      def initialize(runtime)
-        @step_definitions = []
-        @world = JsWorld.new
-        @runtime = runtime
-
-        @world["jsLanguage"] = self
-        @world.load(File.dirname(__FILE__) + '/js_dsl.js')
-      end
-
-      def load_code_file(js_file)
-        @world.load(js_file)
-      end
-
-      def world(js_files)
-        js_files.each do |js_file|
-          load_code_file("#{path_to_load_js_from}#{js_file}")
-        end
-      end
-
-      def alias_adverbs(adverbs)
-      end
-
-      def begin_scenario(scenario)
-        @language = scenario.language
-      end
-
-      def end_scenario
-      end
-
-      def step_matches(name_to_match, name_to_format)
-        @step_definitions.map do |step_definition|
-          if(arguments = step_definition.arguments_from(name_to_match))
-            StepMatch.new(step_definition, name_to_match, name_to_format, arguments)
-          else
-            nil
-          end
-        end.compact
-      end
-
-      def add_step_definition(regexp, js_function)
-        @step_definitions << JsStepDefinition.new(self, regexp, js_function)
-      end
-
-      #TODO: support multiline arguments when calling steps from within steps
-      def execute_step_definition(name, multiline_argument = nil)
-        @runtime.step_match(name).invoke(multiline_argument)
-      end
-
-      def register_js_hook(phase, tag_expressions, js_function)
-        add_hook(phase, JsHook.new(self, tag_expressions, js_function))
-      end
-
-      def register_js_transform(regexp, js_function)
-        add_transform(JsTransform.new(self, regexp, js_function))
-      end
-
-      def current_world
-        @world
-      end
-
-      def steps(steps_text, file_colon_line)
-        @runtime.invoke_steps(steps_text, @language, file_colon_line)
-      end
-
-      private
-      def path_to_load_js_from
-        paths = @runtime.features_paths
-        if paths.empty?
-          '' # Using rake
-        else
-          path = paths[0][/(^.*\/?features)/, 0]
-          path ? "#{path}/../" : '../'
-        end
-      end
-
-    end
-  end
-end

data/lib/cucumber/js_support/js_snippets.rb

@@ -1,27 +0,0 @@
-module Cucumber
-  module JsSupport
-    module JsSnippets
-      PARAM_PATTERN = /"(.*?)"/
-      ESCAPED_PARAM_PATTERN = '"([^\\"]*)"'
-
-      def snippet_text(code_keyword, step_name, multiline_arg_class, snippet_type)
-        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/parser/gherkin_builder.rb

@@ -1,284 +0,0 @@
-require 'cucumber/ast'
-require 'gherkin/rubify'
-require 'cucumber/ast/multiline_argument'
-require 'cucumber/ast/empty_background'
-
-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 initialize(path = 'UNKNOWN-FILE')
-        @path = path
-      end
-
-      def result
-        return nil unless @feature_builder
-        @feature_builder.result(language)
-      end
-
-      def language=(language)
-        @language = language
-      end
-
-      def uri(uri)
-        @path = uri
-      end
-
-      def feature(node)
-        @feature_builder = FeatureBuilder.new(file, node)
-      end
-
-      def background(node)
-        builder = BackgroundBuilder.new(file, node)
-        @feature_builder.background_builder = builder
-        @current = builder
-      end
-
-      def scenario(node)
-        builder = ScenarioBuilder.new(file, node)
-        @feature_builder.add_child builder
-        @current = builder
-      end
-
-      def scenario_outline(node)
-        builder = ScenarioOutlineBuilder.new(file, node)
-        @feature_builder.add_child builder
-        @current = builder
-      end
-
-      def examples(examples)
-        examples_fields = [
-          Ast::Location.new(file, examples.line),
-          Ast::Comment.new(examples.comments.map{|comment| comment.value}.join("\n")),
-          examples.keyword,
-          examples.name,
-          examples.description,
-          matrix(examples.rows)
-        ]
-        @current.add_examples examples_fields, examples
-      end
-
-      def step(node)
-        builder = StepBuilder.new(file, node)
-        @current.add_child builder
-      end
-
-      def eof
-      end
-
-      def syntax_error(state, event, legal_events, line)
-        # raise "SYNTAX ERROR"
-      end
-
-      private
-
-      if defined?(JRUBY_VERSION)
-        java_import java.util.ArrayList
-        ArrayList.__persistent__ = true
-      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
-
-      def language
-        @language || raise("Language has not been set")
-      end
-
-      def file
-        if Cucumber::WINDOWS && !ENV['CUCUMBER_FORWARD_SLASH_PATHS']
-          @path.gsub(/\//, '\\')
-        else
-          @path
-        end
-      end
-
-      class Builder
-        def initialize(file, node)
-          @file, @node = file, node
-        end
-
-        private
-
-        def tags
-          Ast::Tags.new(nil, node.tags)
-        end
-
-        def location
-          Ast::Location.new(file, node.line)
-        end
-
-        def comment
-          Ast::Comment.new(node.comments.map{ |comment| comment.value }.join("\n"))
-        end
-
-        attr_reader :file, :node
-      end
-
-      class FeatureBuilder < Builder
-        def result(language)
-          background = background(language)
-          feature = Ast::Feature.new(
-            location,
-            background,
-            comment,
-            tags,
-            node.keyword,
-            node.name.lstrip,
-            node.description.rstrip,
-            children.map { |builder| builder.result(background, language, tags) }
-          )
-          feature.gherkin_statement(node)
-          feature.language = language
-          feature
-        end
-
-        def background_builder=(builder)
-          @background_builder = builder
-        end
-
-        def add_child(child)
-          children << child
-        end
-
-        def children
-          @children ||= []
-        end
-
-        private
-
-        def background(language)
-          return Ast::EmptyBackground.new unless @background_builder
-          @background ||= @background_builder.result(language)
-        end
-      end
-
-      class BackgroundBuilder < Builder
-        def result(language)
-          background = Ast::Background.new(
-            language,
-            location,
-            comment,
-            node.keyword,
-            node.name,
-            node.description,
-            steps(language)
-          )
-          background.gherkin_statement(node)
-          background
-        end
-
-        def steps(language)
-          children.map { |child| child.result(language) }
-        end
-
-        def add_child(child)
-          children << child
-        end
-
-        def children
-          @children ||= []
-        end
-
-      end
-
-      class ScenarioBuilder < Builder
-        def result(background, language, feature_tags)
-          scenario = Ast::Scenario.new(
-            language,
-            location,
-            background,
-            comment,
-            tags,
-            feature_tags,
-            node.keyword,
-            node.name,
-            node.description,
-            steps(language)
-          )
-          scenario.gherkin_statement(node)
-          scenario
-        end
-
-        def steps(language)
-          children.map { |child| child.result(language) }
-        end
-
-        def add_child(child)
-          children << child
-        end
-
-        def children
-          @children ||= []
-        end
-      end
-
-      class ScenarioOutlineBuilder < Builder
-        def result(background, language, feature_tags)
-          scenario_outline = Ast::ScenarioOutline.new(
-            language,
-            location,
-            background,
-            comment,
-            tags,
-            feature_tags,
-            node.keyword,
-            node.name,
-            node.description,
-            steps(language),
-            examples_sections
-          )
-          scenario_outline.gherkin_statement(node)
-          scenario_outline
-        end
-
-        def add_examples(examples_section, node)
-          @examples_sections ||= []
-          @examples_sections << [examples_section, node]
-        end
-
-        def steps(language)
-          children.map { |child| child.result(language) }
-        end
-
-        def add_child(child)
-          children << child
-        end
-
-        def children
-          @children ||= []
-        end
-
-        private
-
-        attr_reader :examples_sections
-      end
-
-      class StepBuilder < Builder
-        def result(language)
-          step = Ast::Step.new(
-            language,
-            location,
-            node.keyword,
-            node.name,
-            Ast::MultilineArgument.from(node.doc_string || node.rows)
-          )
-          step.gherkin_statement(node)
-          step
-        end
-      end
-
-    end
-  end
-end

data/lib/cucumber/parser.rb

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

data/lib/cucumber/py_support/py_dsl.py

@@ -1,10 +0,0 @@
-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

@@ -1,10 +0,0 @@
-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

@@ -1,80 +0,0 @@
-require 'rubypython'
-
-module Cucumber
-  module PySupport
-    class PyLanguage
-      include LanguageSupport::LanguageMethods
-
-      def initialize(runtime)
-        @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 snippet_text(code_keyword, step_name, multiline_arg_class, snippet_type)
-        "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 RubyPython::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

data/lib/cucumber/runtime/features_loader.rb

@@ -1,62 +0,0 @@
-require 'cucumber/errors'
-
-module Cucumber
-  class Runtime
-
-    class FeaturesLoader
-      include Formatter::Duration
-
-      def initialize(feature_files, filters, tag_expression)
-        @feature_files, @filters, @tag_expression = feature_files, filters, tag_expression
-      end
-
-      def features
-        load unless (defined? @features) and @features
-        @features
-      end
-
-    private
-
-      def load
-        features = Ast::Features.new
-
-        tag_counts = {}
-        start = Time.new
-        log.debug("Features:\n")
-        @feature_files.each do |f|
-          feature_file = FeatureFile.new(f)
-          feature = feature_file.parse(@filters, tag_counts)
-          if feature
-            features.add_feature(feature)
-            log.debug("  * #{f}\n")
-          end
-        end
-        duration = Time.now - start
-        log.debug("Parsing feature files took #{format_duration(duration)}\n\n")
-
-        check_tag_limits(tag_counts)
-
-        @features = features
-      end
-
-      def check_tag_limits(tag_counts)
-        error_messages = []
-        @tag_expression.limits.each do |tag_name, tag_limit|
-          tag_locations = (tag_counts[tag_name] || [])
-          tag_count = tag_locations.length
-          if tag_count > tag_limit
-            error = "#{tag_name} occurred #{tag_count} times, but the limit was set to #{tag_limit}\n  " +
-              tag_locations.join("\n  ")
-            error_messages << error
-          end
-        end
-        raise TagExcess.new(error_messages) if error_messages.any?
-      end
-
-      def log
-        Cucumber.logger
-      end
-    end
-
-  end
-end