lucid 0.0.4 → 0.0.5

data/lib/lucid/ast/specs.rb

@@ -0,0 +1,38 @@
+module Lucid
+  module AST
+    class Specs #: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 Lucid.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/lucid/ast/step.rb

@@ -0,0 +1,122 @@
+require 'lucid/core_ext/string'
+require 'lucid/step_match'
+require 'lucid/ast/location'
+
+module Lucid
+  module AST
+    class Step #:nodoc:
+      include HasLocation
+
+      attr_reader :keyword, :name, :language
+      attr_writer :step_collection, :options
+      attr_accessor :feature_element, :exception, :multiline_arg
+
+      INDENT = 2
+
+      def initialize(language, location, keyword, name, multiline_arg=nil)
+        @language, @location, @keyword, @name, @multiline_arg = language, location, keyword, name, multiline_arg
+        @language || raise("Language is required!")
+      end
+
+      attr_reader :gherkin_statement
+      def gherkin_statement(statement=nil)
+        @gherkin_statement ||= statement
+      end
+
+      def background?
+        false
+      end
+
+      def status
+        # Step always has status skipped, because Step is always in a ScenarioOutline
+        :skipped
+      end
+
+      def step_invocation
+        StepInvocation.new(self, name, @multiline_arg, [])
+      end
+
+      def step_invocation_from_cells(cells)
+        matched_cells = matched_cells(cells)
+
+        delimited_arguments = delimit_argument_names(cells.to_hash)
+        name                = replace_name_arguments(delimited_arguments)
+        multiline_arg       = @multiline_arg.nil? ? nil : @multiline_arg.arguments_replaced(delimited_arguments)
+
+        StepInvocation.new(self, name, multiline_arg, matched_cells)
+      end
+
+      def accept(visitor)
+        return if Lucid.wants_to_quit
+        # The only time a Step is visited is when it is in a ScenarioOutline.
+        # Otherwise it's always StepInvocation that gets visited instead.
+        visit_step_result(visitor, first_match(visitor), @multiline_arg, :skipped, nil, nil)
+      end
+
+      def visit_step_result(visitor, step_match, multiline_arg, status, exception, background)
+        visitor.visit_step_result(keyword, step_match, @multiline_arg, status, exception, source_indent, background, file_colon_line)
+      end
+
+      def first_match(visitor)
+        # The feature_element is always a ScenarioOutline in this case.
+        feature_element.each_example_row do |cells|
+          argument_hash       = cells.to_hash
+          delimited_arguments = delimit_argument_names(argument_hash)
+          name_to_match       = replace_name_arguments(delimited_arguments)
+          step_match          = visitor.runtime.step_match(name_to_match, name) rescue nil
+          return step_match if step_match
+        end
+        NoStepMatch.new(self, name)
+      end
+
+      def to_sexp
+        [:step, line, keyword, name, (@multiline_arg.nil? ? nil : @multiline_arg.to_sexp)].compact
+      end
+
+      def source_indent
+        feature_element.source_indent(text_length)
+      end
+
+      def text_length(name=name)
+        INDENT + INDENT + keyword.unpack('U*').length + name.unpack('U*').length
+      end
+
+      def backtrace_line
+        @backtrace_line ||= feature_element.backtrace_line("#{keyword}#{name}", line) unless feature_element.nil?
+      end
+
+      def dom_id
+        @dom_id ||= file_colon_line.gsub(/\//, '_').gsub(/\./, '_').gsub(/:/, '_')
+      end
+
+      private
+
+      def matched_cells(cells)
+        col_index = 0
+        cells.select do |cell|
+          header_cell = cell.table.header_cell(col_index)
+          col_index += 1
+          delimited = delimited(header_cell.value)
+          name.index(delimited) || (@multiline_arg && @multiline_arg.has_text?(delimited))
+        end
+      end
+
+      def delimit_argument_names(argument_hash)
+        argument_hash.inject({}) { |h,(name,value)| h[delimited(name)] = value; h }
+      end
+
+      def delimited(s)
+        "<#{s}>"
+      end
+
+      def replace_name_arguments(argument_hash)
+        name_with_arguments_replaced = name
+        argument_hash.each do |key, value|
+          value ||= ''
+          name_with_arguments_replaced = name_with_arguments_replaced.gsub(key, value)
+        end
+        name_with_arguments_replaced
+      end
+    end
+  end
+end

data/lib/lucid/ast/step_collection.rb

@@ -0,0 +1,92 @@
+module Lucid
+  module AST
+    # This class holds an array of Step or StepDefinition.
+    class StepCollection #:nodoc:
+      include Enumerable
+
+      def initialize(steps)
+        @steps = steps
+        @steps.each{|step| step.step_collection = self}
+      end
+
+      def inspect
+        @steps.map { |s| [s.class, s.object_id] }.join(', ')
+      end
+
+      def accept(visitor)
+        return if Lucid.wants_to_quit
+        @steps.each do |step|
+          visitor.visit_step(step)
+        end
+      end
+
+      def step_invocations(background = false)
+        StepCollection.new(@steps.map{ |step|
+          i = step.step_invocation
+          i.background = background
+          i
+        })
+      end
+
+      def skip_invoke!
+        @steps.each{|step_invocation| step_invocation.skip_invoke!}
+      end
+
+      def step_invocations_from_cells(cells)
+        @steps.map{|step| step.step_invocation_from_cells(cells)}
+      end
+
+      def +(step_invocations)
+        dup(step_invocations)
+      end
+
+      # Duplicates this instance and adds +step_invocations+ to the end
+      def dup(step_invocations = [])
+        StepCollection.new(@steps + step_invocations)
+      end
+
+      def each(&proc)
+        @steps.each(&proc)
+      end
+
+      def previous_step(step)
+        i = @steps.index(step) || -1
+        @steps[i-1]
+      end
+
+      def empty?
+        @steps.empty?
+      end
+
+      def max_line_length(feature_element)
+        lengths = (@steps + [feature_element]).map{|e| e.text_length}
+        lengths.max
+      end
+
+      def exception
+        @exception ||= ((failed = @steps.detect {|step| step.exception}) && failed.exception)
+      end
+
+      def failed?
+        status == :failed
+      end
+
+      def passed?
+        status == :passed
+      end
+
+      def status
+        @steps.each{|step_invocation| return step_invocation.status if step_invocation.status != :passed}
+        :passed
+      end
+
+      def length
+        @steps.length
+      end
+
+      def to_sexp
+        @steps.map{|step| step.to_sexp}
+      end
+    end
+  end
+end

data/lib/lucid/ast/step_invocation.rb

@@ -0,0 +1,196 @@
+require 'lucid/errors'
+require 'lucid/step_match'
+require 'lucid/ast/table'
+require 'gherkin/rubify'
+
+module Lucid
+  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 Lucid.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 Lucid::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
+
+      BACKTRACE_FILTER_PATTERNS = [/vendor\/rails|lib\/lucid|bin\/lucid:|lib\/rspec|gems\/|minitest|test\/unit/]
+
+      if(Lucid::JRUBY)
+        BACKTRACE_FILTER_PATTERNS << /org\/jruby/
+      end
+
+      PWD_PATTERN = /#{Regexp.escape(Dir.pwd)}\//m
+
+      def filter_backtrace(e)
+        return e if Lucid.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['LUCID_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