cucumber 1.3.20 → 2.0.0.beta.1

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,101 +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
-
-    module FixRuby21Bug9285
-      def message
-        String(super).gsub("@ rb_sysopen ", "")
-      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."
-          e.extend FixRuby21Bug9285 if Cucumber::RUBY_2_1
-          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;