cucumber 1.3.20 → 2.0.0.beta.1

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.rb

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

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