cucumber 1.3.10 → 2.0.0

data/lib/cucumber/ast/step_invocation.rb

@@ -1,196 +0,0 @@
-require 'cucumber/errors'
-require 'cucumber/step_match'
-require 'cucumber/ast/table'
-require 'gherkin/rubify'
-
-module Cucumber
-  module Ast
-    class StepInvocation #:nodoc:
-      include Gherkin::Rubify
-
-      attr_writer :step_collection, :background
-      attr_reader :name, :matched_cells, :status, :reported_exception
-      attr_accessor :exception
-
-      class << self
-        SEVERITY = [:passed, :undefined, :pending, :skipped, :failed]
-        def worst_status(statuses)
-          SEVERITY[statuses.map{|status| SEVERITY.index(status)}.max]
-        end
-      end
-
-      def initialize(step, name, multiline_arg, matched_cells)
-        @step, @name, @multiline_arg, @matched_cells = step, name, multiline_arg, matched_cells
-        status!(:skipped)
-        @skip_invoke = @exception = @step_match = @different_table = @reported_exception = @background = nil
-      end
-
-      def background?
-        @background
-      end
-
-      def skip_invoke!
-        @skip_invoke = true
-      end
-
-      def accept(visitor)
-        return if Cucumber.wants_to_quit
-        invoke(visitor.runtime, visitor.configuration)
-        visit_step_result(visitor)
-      end
-
-      def visit_step_result(visitor)
-        visitor.visit_step_result(
-          keyword,
-          @step_match,
-          (@different_table || @multiline_arg),
-          @status,
-          @reported_exception,
-          source_indent,
-          @background,
-          file_colon_line
-        )
-      end
-
-      def invoke(runtime, configuration)
-        find_step_match!(runtime, configuration)
-        unless @skip_invoke || configuration.dry_run? || @exception || @step_collection.exception
-          @skip_invoke = true
-          begin
-            @step_match.invoke(@multiline_arg)
-            runtime.after_step
-            status!(:passed)
-          rescue Pending => e
-            failed(configuration, e, false)
-            status!(:pending)
-          rescue Undefined => e
-            failed(configuration, e, false)
-            status!(:undefined)
-          rescue Cucumber::Ast::Table::Different => e
-            @different_table = e.table
-            failed(configuration, e, false)
-            status!(:failed)
-          rescue Exception => e
-            failed(configuration, e, false)
-            status!(:failed)
-          end
-        end
-      end
-
-      def find_step_match!(runtime, configuration)
-        return if @step_match
-        begin
-          @step_match = runtime.step_match(@name)
-        rescue Undefined => e
-          failed(configuration, e, true)
-          status!(:undefined)
-          @step_match = NoStepMatch.new(@step, @name)
-        rescue Ambiguous => e
-          failed(configuration, e, false)
-          status!(:failed)
-          @step_match = NoStepMatch.new(@step, @name)
-        end
-        runtime.step_visited(self)
-      end
-
-      def failed(configuration, e, clear_backtrace)
-        e.set_backtrace([]) if e.backtrace.nil? || clear_backtrace
-        e.backtrace << @step.backtrace_line unless @step.backtrace_line.nil?
-        e = filter_backtrace(e)
-        @exception = e
-        if(configuration.strict? || !(Undefined === e) || e.nested?)
-          @reported_exception = e
-        else
-          @reported_exception = nil
-        end
-      end
-
-      # This constant is appended to by Cuke4Duke. Do not change its name
-      BACKTRACE_FILTER_PATTERNS = [/vendor\/rails|lib\/cucumber|bin\/cucumber:|lib\/rspec|gems\/|minitest|test\/unit/]
-      if(Cucumber::JRUBY)
-        BACKTRACE_FILTER_PATTERNS << /org\/jruby/
-      end
-      PWD_PATTERN = /#{Regexp.escape(Dir.pwd)}\//m
-
-      # This is to work around double ":in " segments in JRuby backtraces. JRuby bug?
-      def filter_backtrace(e)
-        return e if Cucumber.use_full_backtrace
-        e.backtrace.each{|line| line.gsub!(PWD_PATTERN, "./")}
-
-        filtered = (e.backtrace || []).reject do |line|
-          BACKTRACE_FILTER_PATTERNS.detect { |p| line =~ p }
-        end
-
-        if ENV['CUCUMBER_TRUNCATE_OUTPUT']
-          # Strip off file locations
-          filtered = filtered.map do |line|
-            line =~ /(.*):in `/ ? $1 : line
-          end
-        end
-
-        e.set_backtrace(filtered)
-        e
-      end
-
-      def status!(status)
-        @status = status
-        @matched_cells.each do |cell|
-          cell.status = status
-        end
-      end
-
-      def previous
-        @step_collection.previous_step(self)
-      end
-
-      def actual_keyword
-        repeat_keywords = rubify([language.keywords('but'), language.keywords('and')]).flatten.uniq.reject{|kw| kw == '* '}
-        if repeat_keywords.index(@step.keyword) && previous
-          previous.actual_keyword
-        else
-          keyword == '* ' ? language.code_keywords.first : keyword
-        end
-      end
-
-      def source_indent
-        @step.feature_element.source_indent(text_length)
-      end
-
-      def text_length
-        @step.text_length(@name)
-      end
-
-      def keyword
-        @step.keyword
-      end
-
-      def multiline_arg
-        @step.multiline_arg
-      end
-
-      def file_colon_line
-        @step.file_colon_line
-      end
-
-      def dom_id
-        @step.dom_id
-      end
-
-      def backtrace_line
-        @step.backtrace_line
-      end
-
-      def language
-        @step.language || raise("Language is required on #{@step}")
-      end
-
-      def gherkin_statement
-        @step.gherkin_statement
-      end
-
-      def to_sexp
-        [:step_invocation, @step.line, @step.keyword, @name, (@multiline_arg.nil? ? nil : @multiline_arg.to_sexp)].compact
-      end
-    end
-  end
-end

data/lib/cucumber/ast/tags.rb

@@ -1,28 +0,0 @@
-require 'gherkin/tag_expression'
-
-module Cucumber
-  module Ast
-    class Tags #:nodoc:
-      attr_reader :tags
-
-      def initialize(line, tags)
-        @line, @tags = line, tags
-      end
-
-      def accept(visitor)
-        return if Cucumber.wants_to_quit
-        @tags.each do |tag|
-          visitor.visit_tag_name(tag.name)
-        end
-      end
-
-      def accept_hook?(hook)
-        Gherkin::TagExpression.new(hook.tag_expressions).evaluate(@tags)
-      end
-
-      def to_sexp
-        @tags.map{|tag| [:tag, tag.name]}
-      end
-    end
-  end
-end

data/lib/cucumber/ast/tree_walker.rb

@@ -1,191 +0,0 @@
-module Cucumber
-  module Ast
-    # Walks the AST, executing steps and notifying listeners
-    class TreeWalker
-      attr_accessor :configuration #:nodoc:
-      attr_reader   :runtime #:nodoc:
-
-      def initialize(runtime, listeners = [], configuration = Cucumber::Configuration.default)
-        @runtime, @listeners, @configuration = runtime, listeners, configuration
-      end
-
-      def execute(scenario, skip_hooks)
-        runtime.with_hooks(scenario, skip_hooks) do
-          scenario.skip_invoke! if scenario.failed?
-          visit_steps(scenario.steps)
-        end
-      end
-
-      def visit_features(features)
-        broadcast(features) do
-          features.accept(self)
-        end
-      end
-
-      def visit_feature(feature)
-        broadcast(feature) do
-          feature.accept(self)
-        end
-      end
-
-      def visit_comment(comment)
-        broadcast(comment) do
-          comment.accept(self)
-        end
-      end
-
-      def visit_comment_line(comment_line)
-        broadcast(comment_line)
-      end
-
-      def visit_tags(tags)
-        broadcast(tags) do
-          tags.accept(self)
-        end
-      end
-
-      def visit_tag_name(tag_name)
-        broadcast(tag_name)
-      end
-
-      def visit_feature_name(keyword, name)
-        broadcast(keyword, name)
-      end
-
-      # +feature_element+ is either Scenario or ScenarioOutline
-      def visit_feature_element(feature_element)
-        broadcast(feature_element) do
-          feature_element.accept(self)
-        end
-      end
-
-      def visit_background(background)
-        broadcast(background) do
-          background.accept(self)
-        end
-      end
-
-      def visit_background_name(keyword, name, file_colon_line, source_indent)
-        broadcast(keyword, name, file_colon_line, source_indent)
-      end
-
-      def visit_examples_array(examples_array)
-        broadcast(examples_array) do
-          examples_array.accept(self)
-        end
-      end
-
-      def visit_examples(examples)
-        broadcast(examples) do
-          examples.accept(self)
-        end
-      end
-
-      def visit_examples_name(keyword, name)
-        broadcast(keyword, name)
-      end
-
-      def visit_outline_table(outline_table)
-        broadcast(outline_table) do
-          outline_table.accept(self)
-        end
-      end
-
-      def visit_scenario_name(keyword, name, file_colon_line, source_indent)
-        broadcast(keyword, name, file_colon_line, source_indent)
-      end
-
-      def visit_steps(steps)
-        broadcast(steps) do
-          steps.accept(self)
-        end
-      end
-
-      def visit_step(step)
-        broadcast(step) do
-          step.accept(self)
-        end
-      end
-
-      def visit_step_result(keyword, step_match, multiline_arg, status, exception, source_indent, background, file_colon_line)
-        broadcast(keyword, step_match, multiline_arg, status, exception, source_indent, background, file_colon_line) do
-          visit_step_name(keyword, step_match, status, source_indent, background, file_colon_line)
-          visit_multiline_arg(multiline_arg) if multiline_arg
-          visit_exception(exception, status) if exception
-        end
-      end
-
-      def visit_step_name(keyword, step_match, status, source_indent, background, file_colon_line) #:nodoc:
-        broadcast(keyword, step_match, status, source_indent, background, file_colon_line)
-      end
-
-      def visit_multiline_arg(multiline_arg) #:nodoc:
-        broadcast(multiline_arg) do
-          multiline_arg.accept(self)
-        end
-      end
-
-      def visit_exception(exception, status) #:nodoc:
-        broadcast(exception, status)
-      end
-
-      def visit_doc_string(string)
-        broadcast(string)
-      end
-
-      def visit_table_row(table_row)
-        broadcast(table_row) do
-          table_row.accept(self)
-        end
-      end
-
-      def visit_table_cell(table_cell)
-        broadcast(table_cell) do
-          table_cell.accept(self)
-        end
-      end
-
-      def visit_table_cell_value(value, status)
-        broadcast(value, status)
-      end
-
-      # Print +messages+. This method can be called from within StepDefinitions.
-      def puts(*messages)
-        broadcast(*messages)
-      end
-
-      # Embed +file+ of +mime_type+ in the formatter. This method can be called from within StepDefinitions.
-      # For most formatters this is a no-op.
-      def embed(file, mime_type, label)
-        broadcast(file, mime_type, label)
-      end
-
-      private
-
-      def broadcast(*args, &block)
-        message = extract_method_name_from(caller)
-        message.gsub!('visit_', '')
-        if block_given?
-          send_to_all("before_#{message}", *args)
-          yield if block_given?
-          send_to_all("after_#{message}", *args)
-        else
-          send_to_all(message, *args)
-        end
-        self
-      end
-
-      def send_to_all(message, *args)
-        @listeners.each do |listener|
-          if listener.respond_to?(message)
-            listener.__send__(message, *args)
-          end
-        end
-      end
-      def extract_method_name_from(call_stack)
-        call_stack[0].match(/in `(.*)'/).captures[0]
-      end
-
-    end
-  end
-end

data/lib/cucumber/ast/visitor.rb

@@ -1,11 +0,0 @@
-module Cucumber
-  module Ast
-    class Visitor
-      DEPRECATION_WARNING = "Cucumber::Ast::Visitor is deprecated and will be removed. You no longer need to inherit from this class."
-
-      def initialize(runtime)
-        raise(DEPRECATION_WARNING)
-      end
-    end
-  end
-end

data/lib/cucumber/broadcaster.rb

@@ -1,13 +0,0 @@
-module Cucumber
-  class Broadcaster #:nodoc:
-    def initialize(receivers = [])
-      @receivers = receivers
-    end
-
-    def method_missing(method_name, *args)
-      @receivers.map do |receiver|
-        receiver.__send__(method_name, *args)
-      end
-    end
-  end
-end

data/lib/cucumber/cli/drb_client.rb

@@ -1,43 +0,0 @@
-require "drb/drb"
-# This code was taken from the RSpec project and slightly modified.
-
-module Cucumber
-  module Cli
-    class DRbClientError < StandardError
-    end
-    # Runs features on a DRB server, originally created with Spork compatibility in mind.
-    class DRbClient
-      DEFAULT_PORT = 8990
-
-      class << self
-
-        def run(args, error_stream, out_stream, port = nil)
-          port ||= ENV["CUCUMBER_DRB"] || DEFAULT_PORT
-
-          setup_support_for_io_streams_over_drb
-
-          feature_server = DRbObject.new_with_uri("druby://127.0.0.1:#{port}")
-          cloned_args = [] # I have no idea why this is needed, but if the regular args are sent then DRb magically transforms it into a DRb object - not an array
-          args.each { |arg| cloned_args << arg }
-          feature_server.run(cloned_args, error_stream, out_stream)
-        rescue DRb::DRbConnError
-          raise DRbClientError, "No DRb server is running."
-        end
-
-        private
-        def setup_support_for_io_streams_over_drb
-          # See http://redmine.ruby-lang.org/issues/show/496 as to why we specify localhost:0
-          begin
-            DRb.start_service("druby://localhost:0")
-          rescue SocketError, Errno::EADDRNOTAVAIL
-            # Ruby-1.8.7 on snow leopard doesn't like localhost:0 - but just :0
-            # seems to work just fine
-            DRb.start_service("druby://:0")
-          end
-        end
-
-      end
-
-    end
-  end
-end

data/lib/cucumber/feature_file.rb

@@ -1,94 +0,0 @@
-require 'cucumber/parser/gherkin_builder'
-require 'gherkin/formatter/filter_formatter'
-require 'gherkin/formatter/tag_count_formatter'
-require 'gherkin/parser/parser'
-
-module Cucumber
-  class FeatureFile
-    FILE_COLON_LINE_PATTERN = /^([\w\W]*?):([\d:]+)$/ #:nodoc:
-    DEFAULT_ENCODING = "UTF-8" #:nodoc:
-    COMMENT_OR_EMPTY_LINE_PATTERN = /^\s*#|^\s*$/ #:nodoc:
-    ENCODING_PATTERN = /^\s*#\s*encoding\s*:\s*([^\s]+)/ #:nodoc:
-
-    # The +uri+ argument is the location of the source. It can be a path
-    # or a path:line1:line2 etc. If +source+ is passed, +uri+ is ignored.
-    def initialize(uri, source=nil)
-      @source = source
-      _, @path, @lines = *FILE_COLON_LINE_PATTERN.match(uri)
-      if @path
-        @lines = @lines.split(':').map { |line| line.to_i }
-      else
-        @path = uri
-      end
-    end
-
-    # Parses a file and returns a Cucumber::Ast::Feature
-    # If +configuration_filters+ contains any filters, the result will
-    # be filtered.
-    def parse(configuration_filters, tag_counts)
-      filters = @lines || configuration_filters
-
-      builder             = Cucumber::Parser::GherkinBuilder.new(@path)
-      filter_formatter    = filters.empty? ? builder : Gherkin::Formatter::FilterFormatter.new(builder, filters)
-      tag_count_formatter = Gherkin::Formatter::TagCountFormatter.new(filter_formatter, tag_counts)
-      parser              = Gherkin::Parser::Parser.new(tag_count_formatter, true, "root", false)
-
-      begin
-        parser.parse(source, @path, 0)
-        builder.language = parser.i18n_language
-        builder.result
-      rescue Gherkin::Lexer::LexingError, Gherkin::Parser::ParseError => e
-        e.message.insert(0, "#{@path}: ")
-        raise e
-      end
-    end
-
-    def source
-      @source ||= if @path =~ /^http/
-        require 'open-uri'
-        open(@path).read
-      else
-        begin
-          source = File.open(@path, Cucumber.file_mode('r', DEFAULT_ENCODING)).read
-          encoding = encoding_for(source)
-          if(DEFAULT_ENCODING.downcase != encoding.downcase)
-            # Read the file again - it's explicitly declaring a different encoding
-            source = File.open(@path, Cucumber.file_mode('r', encoding)).read
-            source = to_default_encoding(source, encoding)
-          end
-          source
-        rescue Errno::EACCES => e
-          e.message << "\nCouldn't open #{File.expand_path(@path)}"
-          raise e
-        rescue Errno::ENOENT => e
-          # special-case opening features, because this could be a new user:
-          e.message << ". Please create a #{@path} directory to get started."
-          raise e
-        end
-      end
-    end
-
-    private
-
-    def encoding_for(source)
-      encoding = DEFAULT_ENCODING
-      source.each_line do |line|
-        break unless COMMENT_OR_EMPTY_LINE_PATTERN =~ line
-        if ENCODING_PATTERN =~ line
-          encoding = $1
-          break
-        end
-      end
-      encoding
-    end
-
-    def to_default_encoding(string, encoding)
-      if string.respond_to?(:encode)
-        string.encode(DEFAULT_ENCODING)
-      else
-        require 'iconv'
-        Iconv.new(DEFAULT_ENCODING, encoding).iconv(string)
-      end
-    end
-  end
-end

data/lib/cucumber/formatter/ordered_xml_markup.rb

@@ -1,24 +0,0 @@
-begin
-  require 'builder'
-rescue LoadError
-  gem 'builder'
-  require 'builder'
-end
-
-module Cucumber
-  module Formatter
-    # Emits attributes ordered alphabetically, so that we can predicatbly test output.
-    class OrderedXmlMarkup < Builder::XmlMarkup #:nodoc:
-      def _insert_attributes(attrs, order=[])
-        return if attrs.nil?
-        keys = attrs.keys.map{|k| k.to_s}
-        keys.sort!
-        keys.reverse! if (attrs.keys - [:version, :encoding] == []) #HACK to ensure the 'version' attribute is first in xml declaration.
-        keys.each do |k|
-          v = attrs[k.to_sym] || attrs[k]
-          @target << %{ #{k}="#{_attr_value(v)}"} if v
-        end
-      end
-    end
-  end
-end

data/lib/cucumber/js_support/js_dsl.js

@@ -1,57 +0,0 @@
-var CucumberJsDsl = {
-  registerStepDefinition: function(regexp, func) {
-    if(func == null) {
-      jsLanguage.execute_step_definition(regexp);
-    }
-    else{
-      jsLanguage.add_step_definition(regexp, func);
-    }
-  },
-
-  registerTransform: function(regexp, func) {
-    jsLanguage.register_js_transform(regexp, func);
-  },
-
-  beforeHook: function(tag_expressions_or_func, func) {
-    CucumberJsDsl.__registerJsHook('before', tag_expressions_or_func, func);
-  },
-
-  afterHook: function(tag_expressions_or_func, func) {
-    CucumberJsDsl.__registerJsHook('after', tag_expressions_or_func, func);
-  },
-
-  steps: function(step_names) {
-    jsLanguage.steps(step_names, "UNKNOWN:0");
-  },
-
-  Table: function(raw_table) {
-    //TODO: Create a ruby table and send it back for use in js world
-  },
-
-  world: function(files) {
-    jsLanguage.world(files);
-  },
-
-  __registerJsHook: function(label, tag_expressions_or_func, func) {
-    if(func != null) {
-      var hook_func = func;
-      var tag_expressions = tag_expressions_or_func;
-    } else {
-      var hook_func = tag_expressions_or_func;
-      var tag_expressions = [];
-    }
-    jsLanguage.register_js_hook(label, tag_expressions, hook_func);
-  }
-}
-
-var Given = CucumberJsDsl.registerStepDefinition;
-var When = CucumberJsDsl.registerStepDefinition;
-var Then = CucumberJsDsl.registerStepDefinition;
-
-var Before = CucumberJsDsl.beforeHook;
-var After = CucumberJsDsl.afterHook;
-var Transform = CucumberJsDsl.registerTransform;
-
-var World = CucumberJsDsl.world;
-
-var steps = CucumberJsDsl.steps;