cucumber 1.3.20 → 2.0.0.beta.1

data/lib/cucumber/ast/comment.rb

@@ -1,31 +0,0 @@
-module Cucumber
-  module Ast
-    # Holds the value of a comment parsed from a feature file:
-    #
-    #   # Lorem ipsum
-    #   # dolor sit amet
-    #
-    # This gets parsed into a Comment with value <tt>"# Lorem ipsum\n# dolor sit amet\n"</tt>
-    #
-    class Comment #:nodoc:
-      def initialize(value)
-        @value = value
-      end
-
-      def empty?
-        @value.nil? || @value == ""
-      end
-
-      def accept(visitor)
-        return if Cucumber.wants_to_quit
-        @value.strip.split("\n").each do |line|
-          visitor.visit_comment_line(line.strip)
-        end
-      end
-
-      def to_sexp
-        (@value.nil? || @value == '') ? nil : [:comment, @value]
-      end
-    end
-  end
-end

data/lib/cucumber/ast/doc_string.rb

@@ -1,61 +0,0 @@
-module Cucumber
-  module Ast
-    # Represents an inline argument in a step. Example:
-    #
-    #   Given the message
-    #     """
-    #     I like
-    #     Cucumber sandwich
-    #     """
-    #
-    # The text between the pair of <tt>"""</tt> is stored inside a DocString,
-    # which is yielded to the StepDefinition block as the last argument.
-    #
-    # The StepDefinition can then access the String via the #to_s method. In the
-    # example above, that would return: <tt>"I like\nCucumber sandwich"</tt>
-    #
-    # Note how the indentation from the source is stripped away.
-    #
-    class DocString < String #:nodoc:
-      attr_accessor :file
-
-      def self.default_arg_name
-        "string"
-      end
-
-      attr_reader :content_type
-
-      def initialize(string, content_type)
-        @content_type = content_type
-        super string
-      end
-
-      def to_step_definition_arg
-        self
-      end
-
-      def accept(visitor)
-        return if Cucumber.wants_to_quit
-        visitor.visit_doc_string(self)
-      end
-
-      def arguments_replaced(arguments) #:nodoc:
-        string = self
-        arguments.each do |name, value|
-          value ||= ''
-          string = string.gsub(name, value)
-        end
-        DocString.new(string, content_type)
-      end
-
-      def has_text?(text)
-        index(text)
-      end
-
-      # For testing only
-      def to_sexp #:nodoc:
-        [:doc_string, to_step_definition_arg]
-      end
-    end
-  end
-end

data/lib/cucumber/ast/empty_background.rb

@@ -1,33 +0,0 @@
-require 'cucumber/ast/step_collection'
-
-module Cucumber
-  module Ast
-    class EmptyBackground
-      attr_writer :file
-      attr_accessor :feature
-
-      def failed?
-        false
-      end
-
-      def feature_elements
-        []
-      end
-
-      def step_collection(step_invocations)
-        StepCollection.new(step_invocations)
-      end
-
-      def step_invocations
-        []
-      end
-
-      def init
-      end
-
-      def accept(visitor)
-      end
-    end
-  end
-end
-

data/lib/cucumber/ast/examples.rb

@@ -1,49 +0,0 @@
-require 'cucumber/ast/names'
-
-module Cucumber
-  module Ast
-    class Examples #:nodoc:
-      include Names
-      include HasLocation
-      attr_writer :outline_table
-
-      def initialize(location, comment, keyword, title, description, outline_table)
-        @location, @comment, @keyword, @title, @description, @outline_table = location, comment, keyword, title, description, outline_table
-        raise ArgumentError unless @location.is_a?(Location)
-        raise ArgumentError unless @comment.is_a?(Comment)
-      end
-
-      attr_reader :gherkin_statement
-      def gherkin_statement(statement=nil)
-        @gherkin_statement ||= statement
-      end
-
-      def accept(visitor)
-        return if Cucumber.wants_to_quit
-        visitor.visit_comment(@comment) unless @comment.empty?
-        visitor.visit_examples_name(@keyword, name)
-        visitor.visit_outline_table(@outline_table)
-      end
-
-      def skip_invoke!
-        @outline_table.skip_invoke!
-      end
-
-      def each_example_row(&proc)
-        @outline_table.cells_rows[1..-1].each(&proc)
-      end
-
-      def failed?
-        @outline_table.cells_rows[1..-1].select{|row| row.failed?}.any?
-      end
-
-      def to_sexp
-        sexp = [:examples, @keyword, name]
-        comment = @comment.to_sexp
-        sexp += [comment] if comment
-        sexp += [@outline_table.to_sexp]
-        sexp
-      end
-    end
-  end
-end

data/lib/cucumber/ast/feature.rb

@@ -1,99 +0,0 @@
-require 'cucumber/ast/names'
-require 'cucumber/ast/location'
-require 'cucumber/ast/location'
-
-module Cucumber
-  module Ast
-    # Represents the root node of a parsed feature.
-    class Feature #:nodoc:
-      include Names
-      include HasLocation
-
-      attr_accessor :language
-      attr_reader :feature_elements
-
-      def initialize(location, background, comment, tags, keyword, title, description, feature_elements)
-        @background, @comment, @tags, @keyword, @title, @description, @feature_elements = background, comment, tags, keyword, title, description, feature_elements
-        @background.feature = self
-        @location = location
-        @feature_elements.each { |e| e.feature = self }
-      end
-
-      attr_reader :gherkin_statement
-      def gherkin_statement(statement=nil)
-        @gherkin_statement ||= statement
-      end
-
-      def step_count
-        units.inject(0) { |total, unit| total += unit.step_count }
-      end
-
-      def accept(visitor)
-        return if Cucumber.wants_to_quit
-        visitor.visit_comment(@comment) unless @comment.empty?
-        visitor.visit_tags(@tags)
-        visitor.visit_feature_name(@keyword, indented_name)
-        visitor.visit_background(@background) if !@background.is_a?(EmptyBackground)
-        @feature_elements.each do |feature_element|
-          visitor.visit_feature_element(feature_element)
-        end
-      end
-
-      def indented_name
-        indent = ""
-        name.split("\n").map do |l|
-          s = "#{indent}#{l}"
-          indent = "  "
-          s
-        end.join("\n")
-      end
-
-      def source_tags
-        @tags.tags
-      end
-
-      def source_tag_names
-        source_tags.map { |tag| tag.name }
-      end
-
-      def accept_hook?(hook)
-        @tags.accept_hook?(hook)
-      end
-
-      def backtrace_line(step_name, line)
-        "#{location.on_line(line)}:in `#{step_name}'"
-      end
-
-      def short_name
-        first_line = name.split(/\n/)[0]
-        if first_line =~ /#{language.keywords('feature')}:(.*)/
-          $1.strip
-        else
-          first_line
-        end
-      end
-
-      def to_sexp
-        sexp = [:feature, file, name]
-        comment = @comment.to_sexp
-        sexp += [comment] if comment
-        tags = @tags.to_sexp
-        sexp += tags if tags.any?
-        sexp += [@background.to_sexp] if @background
-        sexp += @feature_elements.map{|fe| fe.to_sexp}
-        sexp
-      end
-
-      private
-
-      attr_reader :background
-
-      def units
-        @units ||= @feature_elements.map do |element| 
-          element.to_units(background)
-        end.flatten
-      end
-
-    end
-  end
-end

data/lib/cucumber/ast/features.rb

@@ -1,38 +0,0 @@
-module Cucumber
-  module Ast
-    class Features #:nodoc:
-      include Enumerable
-
-      attr_reader :duration
-
-      def initialize
-        @features = []
-      end
-
-      def [](index)
-        @features[index]
-      end
-
-      def each(&proc)
-        @features.each(&proc)
-      end
-
-      def add_feature(feature)
-        @features << feature
-      end
-
-      def accept(visitor)
-        return if Cucumber.wants_to_quit
-        start = Time.now
-        self.each do |feature|
-          visitor.visit_feature(feature)
-        end
-        @duration = Time.now - start
-      end
-
-      def step_count
-        @features.inject(0) { |total, feature| total += feature.step_count }
-      end
-    end
-  end
-end

data/lib/cucumber/ast/has_steps.rb

@@ -1,74 +0,0 @@
-require 'enumerator'
-require 'gherkin/tag_expression'
-
-module Cucumber
-  module Ast
-    module HasSteps #:nodoc:
-      attr_reader :gherkin_statement, :raw_steps, :title, :description
-      def gherkin_statement(statement=nil)
-        @gherkin_statement ||= statement
-      end
-
-      def attach_steps(steps)
-        steps.each do |step| 
-          step.feature_element = self
-        end
-      end
-
-      def first_line_length
-        name_line_lengths[0]
-      end
-
-      def text_length
-        name_line_lengths.max
-      end
-
-      def name_line_lengths
-        if name.strip.empty?
-          [Ast::Step::INDENT + @keyword.unpack('U*').length + ': '.length]
-        else
-          name.split("\n").enum_for(:each_with_index).map do |line, line_number|
-            if line_number == 0
-              Ast::Step::INDENT + @keyword.unpack('U*').length + ': '.length + line.unpack('U*').length
-            else
-              Ast::Step::INDENT + Ast::Step::INDENT + line.unpack('U*').length
-            end
-          end
-        end
-      end
-
-      def matches_scenario_names?(scenario_name_regexps)
-        scenario_name_regexps.detect{|n| n =~ name}
-      end
-
-      def backtrace_line(step_name = "#{@keyword}: #{name}", line = self.line)
-        "#{location.on_line(line)}:in `#{step_name}'"
-      end
-
-      def source_indent(text_length)
-        max_line_length - text_length
-      end
-
-      def max_line_length
-        steps.max_line_length(self)
-      end
-
-      def accept_hook?(hook)
-        Gherkin::TagExpression.new(hook.tag_expressions).evaluate(source_tags)
-      end
-
-      def source_tag_names
-        source_tags.map { |tag| tag.name }
-      end
-
-      def source_tags
-        @tags.tags.to_a + feature_tags.tags.to_a
-      end
-
-      def language
-        @language || raise("Language is required for a #{self.class}")
-      end
-
-    end
-  end
-end

data/lib/cucumber/ast/location.rb

@@ -1,41 +0,0 @@
-module Cucumber
-  module Ast
-
-    class Location
-      attr_reader :file, :line
-
-      def initialize(file, line)
-        @file = file || raise(ArgumentError, "file is mandatory")
-        @line = line || raise(ArgumentError, "line is mandatory")
-      end
-
-      def to_s
-        "#{file}:#{line}"
-      end
-
-      def on_line(new_line)
-        Location.new(file, new_line)
-      end
-    end
-
-    module HasLocation
-      def file_colon_line
-        location.to_s
-      end
-
-      def file
-        location.file
-      end
-
-      def line
-        location.line
-      end
-
-      def location
-        raise('Please set @location in the constructor') unless @location
-        raise("@location must be an Ast::Location but is a #{@location.class}") unless @location.is_a?(Location)
-        @location
-      end
-    end
-  end
-end

data/lib/cucumber/ast/multiline_argument.rb

@@ -1,30 +0,0 @@
-require 'gherkin/rubify'
-
-module Cucumber
-  module Ast
-    module MultilineArgument
-
-      class << self
-        include Gherkin::Rubify
-
-        def from(argument)
-          return unless argument
-          return argument if argument.respond_to?(:to_step_definition_arg)
-
-          case(rubify(argument))
-          when String
-            # TODO: this duplicates work that gherkin does. We should really pass the string to gherkin and let it parse it.
-            Ast::DocString.new(argument, '')
-          when Gherkin::Formatter::Model::DocString
-            Ast::DocString.new(argument.value, argument.content_type)
-          when Array
-            Ast::Table.new(argument.map{|row| row.cells})
-          else
-            raise ArgumentError, "Don't know how to convert #{argument} into a MultilineArgument"
-          end
-        end
-
-      end
-    end
-  end
-end