lucid 0.0.4 → 0.0.5

data/lib/lucid/ast/location.rb

@@ -0,0 +1,41 @@
+module Lucid
+  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/lucid/ast/multiline_argument.rb

@@ -0,0 +1,31 @@
+require 'gherkin/rubify'
+
+module Lucid
+  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 already does.
+            # Ideally the string should be passed directly to Gherkin for parsing.
+            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, "Lucid does not know how to convert #{argument} into a multi-line argument."
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/lucid/ast/names.rb

@@ -0,0 +1,13 @@
+module Lucid
+  module AST
+    module Names
+      attr_reader :title, :description
+
+      def name
+        s = @title
+        s += "\n#{@description}" if @description != ""
+        s
+      end
+    end
+  end
+end

data/lib/lucid/ast/outline_table.rb

@@ -0,0 +1,194 @@
+module Lucid
+  module AST
+    class OutlineTable < Table #:nodoc:
+      def initialize(raw, scenario_outline)
+        super(raw)
+        @scenario_outline = scenario_outline
+        @cells_class = ExampleRow
+        init
+      end
+
+      def init
+        create_step_invocations_for_example_rows!(@scenario_outline)
+      end
+
+      def to_sexp
+        init
+        super
+      end
+
+      def accept(visitor)
+        return if Lucid.wants_to_quit
+        init
+        cells_rows.each_with_index do |row, n|
+          if(visitor.configuration.expand?)
+            row.accept(visitor)
+          else
+            visitor.visit_table_row(row)
+          end
+        end
+        nil
+      end
+
+      def accept_hook?(hook)
+        @scenario_outline.accept_hook?(hook)
+      end
+
+      def source_tags
+        @scenario_outline.source_tags
+      end
+
+      def source_tag_names
+        source_tags.map { |tag| tag.name }
+      end
+
+      def skip_invoke!
+        init
+        example_rows.each do |cells|
+          cells.skip_invoke!
+        end
+      end
+
+      def create_step_invocations_for_example_rows!(scenario_outline)
+        return if @dunit
+        @dunit = true
+        example_rows.each do |cells|
+          cells.create_step_invocations!(scenario_outline)
+        end
+      end
+
+      def example_rows
+        cells_rows[1..-1]
+      end
+
+      def visit_scenario_name(visitor, row)
+        @scenario_outline.visit_scenario_name(visitor, row)
+      end
+
+      def language
+        @scenario_outline.language
+      end
+
+      class ExampleRow < Cells #:nodoc:
+        class InvalidForHeaderRowError < NoMethodError
+          def initialize(*args)
+            super 'This is a header row and cannot pass or fail'
+          end
+        end
+
+        attr_reader :scenario_outline # https://rspec.lighthouseapp.com/projects/16211/tickets/342
+
+        def initialize(table, cells)
+          super
+          @scenario_exception = nil
+        end
+
+        def source_tag_names
+          source_tags.map { |tag| tag.name }
+        end
+
+        def source_tags
+          @table.source_tags
+        end
+
+        def create_step_invocations!(scenario_outline)
+          @scenario_outline = scenario_outline
+          @step_invocations = scenario_outline.step_invocations(self)
+        end
+
+        def skip_invoke!
+          @step_invocations.each do |step_invocation|
+            step_invocation.skip_invoke!
+          end
+        end
+
+        def accept(visitor)
+          return if Lucid.wants_to_quit
+          visitor.configuration.expand? ? accept_expand(visitor) : accept_plain(visitor)
+        end
+
+        def accept_plain(visitor)
+          if header?
+            @cells.each do |cell|
+              cell.status = :skipped_param
+              visitor.visit_table_cell(cell)
+            end
+          else
+            visitor.runtime.with_hooks(self) do
+              @step_invocations.each do |step_invocation|
+                step_invocation.invoke(visitor.runtime, visitor.configuration)
+                @exception ||= step_invocation.reported_exception
+              end
+
+              @cells.each do |cell|
+                visitor.visit_table_cell(cell)
+              end
+
+              visitor.visit_exception(@scenario_exception, :failed) if @scenario_exception
+            end
+          end
+        end
+
+        def accept_expand(visitor)
+          if header?
+          else
+            visitor.runtime.with_hooks(self) do
+              @table.visit_scenario_name(visitor, self)
+              @step_invocations.each do |step_invocation|
+                visitor.visit_step(step_invocation)
+                @exception ||= step_invocation.reported_exception
+              end
+            end
+          end
+        end
+
+        def accept_hook?(hook)
+          @table.accept_hook?(hook)
+        end
+
+        def exception
+          @exception || @scenario_exception
+        end
+
+        def fail!(exception)
+          @scenario_exception = exception
+        end
+
+        # Returns true if one or more steps failed
+        def failed?
+          raise InvalidForHeaderRowError if header?
+          @step_invocations.failed? || !!@scenario_exception
+        end
+
+        # Returns true if all steps passed
+        def passed?
+          !failed?
+        end
+
+        # Returns the status
+        def status
+          return :failed if @scenario_exception
+          @step_invocations.status
+        end
+
+        def backtrace_line
+          @scenario_outline.backtrace_line(name, line)
+        end
+
+        def name
+          "| #{@cells.collect{|c| c.value }.join(' | ')} |"
+        end
+
+        def language
+          @table.language
+        end
+
+        private
+
+        def header?
+          index == 0
+        end
+      end
+    end
+  end
+end

data/lib/lucid/ast/scenario.rb

@@ -0,0 +1,103 @@
+require 'lucid/ast/has_steps'
+require 'lucid/ast/names'
+require 'lucid/ast/empty_background'
+require 'lucid/ast/location'
+require 'lucid/unit'
+
+module Lucid
+  module AST
+    class Scenario #:nodoc:
+      include HasSteps
+      include Names
+      include HasLocation
+
+      attr_reader   :feature_tags
+      attr_accessor :feature
+
+      def initialize(language, location, background, comment, tags, feature_tags, keyword, title, description, raw_steps)
+        @language, @location, @background, @comment, @tags, @feature_tags, @keyword, @title, @description, @raw_steps = language, location, background, comment, tags, feature_tags, keyword, title, description, raw_steps
+        @exception = @executed = nil
+        attach_steps(@raw_steps)
+      end
+
+      def accept(visitor)
+        return if Lucid.wants_to_quit
+
+        visitor.visit_comment(@comment) unless @comment.empty?
+        visitor.visit_tags(@tags)
+        visitor.visit_scenario_name(@keyword, name, file_colon_line, source_indent(first_line_length))
+
+        skip_invoke! if @background.failed?
+        with_visitor(visitor) do
+          visitor.execute(self, skip_hooks?)
+        end
+        @executed = true
+      end
+
+      def to_units(background)
+        [Unit.new(background.step_invocations + step_invocations)]
+      end
+
+      # Returns true if one or more steps failed.
+      def failed?
+        steps.failed? || !!@exception
+      end
+
+      def fail!(exception)
+        @exception = exception
+        @current_visitor.visit_exception(@exception, :failed)
+      end
+
+      # Returns true if all steps passed.
+      def passed?
+        !failed?
+      end
+
+      # Returns the first exception (if any).
+      def exception
+        @exception || steps.exception
+      end
+
+      # Returns the status.
+      def status
+        return :failed if @exception
+        steps.status
+      end
+
+      def to_sexp
+        sexp = [:scenario, line, @keyword, name]
+        comment = @comment.to_sexp
+        sexp += [comment] if comment
+        tags = @tags.to_sexp
+        sexp += tags if tags.any?
+        sexp += steps.to_sexp if steps.any?
+        sexp
+      end
+
+      def with_visitor(visitor)
+        @current_visitor = visitor
+        yield
+        @current_visitor = nil
+      end
+
+      def skip_invoke!
+        steps.skip_invoke!
+      end
+
+      def steps
+        @steps ||= @background.step_collection(step_invocations)
+      end
+
+      private
+
+      def step_invocations
+        @raw_steps.map{|step| step.step_invocation}
+      end
+
+      def skip_hooks?
+        @background.failed? || @executed
+      end
+
+    end
+  end
+end

data/lib/lucid/ast/scenario_outline.rb

@@ -0,0 +1,144 @@
+require 'lucid/ast/has_steps'
+require 'lucid/ast/names'
+require 'lucid/ast/empty_background'
+
+module Lucid
+  module AST
+    class ScenarioOutline #:nodoc:
+      include HasSteps
+      include Names
+      include HasLocation
+
+      attr_accessor :feature
+      attr_reader :feature_tags
+
+      module ExamplesArray #:nodoc:
+        def accept(visitor)
+          return if Lucid.wants_to_quit
+          each do |examples|
+            visitor.visit_examples(examples)
+          end
+        end
+      end
+
+      # The +example_sections+ argument must be an Array where each element
+      # of the arry is another array representing an Examples section.
+      def initialize(language, location, background, comment, tags, feature_tags, keyword, title, description, raw_steps, example_sections)
+        @language, @location, @background, @comment, @tags, @feature_tags, @keyword, @title, @description, @raw_steps, @example_sections = language, location, background, comment, tags, feature_tags, keyword, title, description, raw_steps, example_sections
+        attach_steps(@raw_steps)
+      end
+
+      def accept(visitor)
+        return if Lucid.wants_to_quit
+        raise_missing_examples_error unless @example_sections
+
+        visitor.visit_comment(@comment) unless @comment.empty?
+        visitor.visit_tags(@tags)
+        visitor.visit_scenario_name(@keyword, name, file_colon_line, source_indent(first_line_length))
+        visitor.visit_steps(steps)
+
+        skip_invoke! if @background.failed?
+        visitor.visit_examples_array(examples_array) unless examples_array.empty?
+      end
+
+      def to_units(background)
+        raise ArgumentError.new("#{background} != #{@background}") unless background == @background # maybe we don't need this argument, but it seems like the leaf AST nodes would be better not being aware of their parents. However step_invocations uses the ivar at the moment, so we'll just do this check to make sure its OK.
+        result = []
+        each_example_row do |row|
+          result << Unit.new(step_invocations(row))
+        end
+        result
+      end
+
+      def fail!(exception)
+        # TODO: This is weak and is in fact just a hack.
+        # This simply makes sure that a scenario outline that encounters
+        # an exception just fails rather than causing a runtime error
+        # and stack trace.
+      end
+
+      def skip_invoke!
+        examples_array.each { |examples| examples.skip_invoke! }
+      end
+
+      def step_invocations(cells)
+        step_invocations = steps.step_invocations_from_cells(cells)
+        if @background
+          @background.step_collection(step_invocations)
+        else
+          StepCollection.new(step_invocations)
+        end
+      end
+
+      def each_example_row(&proc)
+        examples_array.each do |examples|
+          examples.each_example_row(&proc)
+        end
+      end
+
+      def visit_scenario_name(visitor, row)
+        visitor.visit_scenario_name(
+          language.keywords('scenario')[0],
+          row.name,
+          Location.new(file, row.line).to_s,
+          source_indent(first_line_length)
+        )
+      end
+
+      def failed?
+        examples_array.select { |examples| examples.failed? }.any?
+      end
+
+      def to_sexp
+        sexp = [:scenario_outline, @keyword, name]
+        comment = @comment.to_sexp
+        sexp += [comment] if comment
+        tags = @tags.to_sexp
+        sexp += tags if tags.any?
+        sexp += steps.to_sexp if steps.any?
+        sexp += examples_array.map{|e| e.to_sexp}
+        sexp
+      end
+
+      private
+
+      attr_reader :line
+
+      def examples_array
+        return @examples_array if @examples_array
+        @examples_array = @example_sections.map do |section|
+          create_examples_table(section)
+        end
+        @examples_array.extend(ExamplesArray)
+        @examples_array
+      end
+
+      def create_examples_table(example_section_and_gherkin_examples)
+        example_section = example_section_and_gherkin_examples[0]
+        gherkin_examples = example_section_and_gherkin_examples[1]
+
+        examples_location    = example_section[0]
+        examples_comment     = example_section[1]
+        examples_keyword     = example_section[2]
+        examples_title       = example_section[3]
+        examples_description = example_section[4]
+        examples_matrix      = example_section[5]
+
+        examples_table = OutlineTable.new(examples_matrix, self)
+        ex = Examples.new(examples_location, examples_comment, examples_keyword, examples_title, examples_description, examples_table)
+        ex.gherkin_statement(gherkin_examples)
+        ex
+      end
+
+      def steps
+        @steps ||= StepCollection.new(@raw_steps)
+      end
+
+      def raise_missing_examples_error
+        raise MissingExamples, "Missing Example section for Scenario Outline at #{@location}."
+      end
+
+      MissingExamples = Class.new(StandardError)
+    end
+  end
+end