lucid 0.0.4 → 0.0.5

data/lib/lucid/ast.rb

@@ -0,0 +1,20 @@
+require 'lucid/ast/comment'
+require 'lucid/ast/specs'
+require 'lucid/ast/feature'
+require 'lucid/ast/background'
+require 'lucid/ast/scenario'
+require 'lucid/ast/scenario_outline'
+require 'lucid/ast/step_invocation'
+require 'lucid/ast/step_collection'
+require 'lucid/ast/step'
+require 'lucid/ast/table'
+require 'lucid/ast/tags'
+require 'lucid/ast/doc_string'
+require 'lucid/ast/outline_table'
+require 'lucid/ast/examples'
+require 'lucid/ast/tdl_walker'
+
+module Lucid
+  module AST
+  end
+end

data/lib/lucid/ast/background.rb

@@ -0,0 +1,116 @@
+require 'lucid/ast/has_steps'
+require 'lucid/ast/names'
+require 'lucid/ast/location'
+
+module Lucid
+  module AST
+    class Background #:nodoc:
+      include HasSteps
+      include Names
+      include HasLocation
+      attr_accessor :feature
+
+      def initialize(language, location, comment, keyword, title, description, raw_steps)
+        @language, @location, @comment, @keyword, @title, @description, @raw_steps = language, location, comment, keyword, title, description, raw_steps
+        @failed = nil
+        @first_collection_created = false
+        attach_steps(@raw_steps)
+      end
+
+      def feature_elements
+        feature.feature_elements
+      end
+
+      def step_invocations
+        @step_invocations ||= steps.step_invocations(true)
+      end
+
+      def step_collection(scenario_step_invocations)
+        if(@first_collection_created)
+          steps.step_invocations(true).dup(scenario_step_invocations)
+        else
+          @first_collection_created = true
+          step_invocations.dup(scenario_step_invocations)
+        end
+      end
+
+      def accept(visitor)
+        return if Lucid.wants_to_quit
+        visitor.visit_comment(@comment) unless @comment.empty?
+        visitor.visit_background_name(@keyword, name, file_colon_line, source_indent(first_line_length))
+        with_visitor(hook_context, visitor) do
+          visitor.runtime.before(hook_context)
+          skip_invoke! if failed?
+          visitor.visit_steps(step_invocations)
+          @failed = step_invocations.any? { |step_invocation| step_invocation.exception || step_invocation.status != :passed }
+          visitor.runtime.after(hook_context) if @failed || feature_elements.empty?
+        end
+      end
+
+      def with_visitor(scenario, visitor)
+        @current_visitor = visitor
+        if self != scenario && scenario.respond_to?(:with_visitor)
+          scenario.with_visitor(visitor) do
+            yield
+          end
+        else
+          yield
+        end
+      end
+
+      def accept_hook?(hook)
+        if hook_context != self
+          hook_context.accept_hook?(hook)
+        else
+          # We have no scenarios, just ask our feature
+          feature.accept_hook?(hook)
+        end
+      end
+
+      def skip_invoke!
+        step_invocations.each{|step_invocation| step_invocation.skip_invoke!}
+      end
+
+      def failed?
+        !!@failed
+      end
+
+      def hook_context
+        feature_elements.first || self
+      end
+
+      def to_sexp
+        sexp = [:background, line, @keyword]
+        sexp += [name] unless name.empty?
+        comment = @comment.to_sexp
+        sexp += [comment] if comment
+        sexp += steps.to_sexp if steps.any?
+        sexp
+      end
+
+      def fail!(exception)
+        @failed = true
+        @exception = exception
+        @current_visitor.visit_exception(@exception, :failed)
+      end
+
+      # Override this method, as there are situations where the background
+      # wind up being the one called fore Before scenarios, and
+      # backgrounds don't have tags.
+      def source_tags
+        []
+      end
+
+      def source_tag_names
+        source_tags.map { |tag| tag.name }
+      end
+
+      private
+
+      def steps
+        @steps ||= StepCollection.new(@raw_steps)
+      end
+
+    end
+  end
+end

data/lib/lucid/ast/comment.rb

@@ -0,0 +1,24 @@
+module Lucid
+  module AST
+    class Comment #:nodoc:
+      def initialize(value)
+        @value = value
+      end
+
+      def empty?
+        @value.nil? || @value == ""
+      end
+
+      def accept(visitor)
+        return if Lucid.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/lucid/ast/doc_string.rb

@@ -0,0 +1,44 @@
+module Lucid
+  module AST
+    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 Lucid.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
+
+      def to_sexp #:nodoc:
+        [:doc_string, to_step_definition_arg]
+      end
+    end
+  end
+end

data/lib/lucid/ast/empty_background.rb

@@ -0,0 +1,33 @@
+require 'lucid/ast/step_collection'
+
+module Lucid
+  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/lucid/ast/examples.rb

@@ -0,0 +1,49 @@
+require 'lucid/ast/names'
+
+module Lucid
+  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 Lucid.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/lucid/ast/feature.rb

@@ -0,0 +1,99 @@
+require 'lucid/ast/names'
+require 'lucid/ast/location'
+require 'lucid/ast/location'
+
+module Lucid
+  module AST
+
+    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 Lucid.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/lucid/ast/has_steps.rb

@@ -0,0 +1,74 @@
+require 'enumerator'
+require 'gherkin/tag_expression'
+
+module Lucid
+  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