cucumber-core 0.1.0

data/lib/cucumber/core/ast/names.rb

@@ -0,0 +1,19 @@
+module Cucumber
+  module Core
+    module Ast
+      module Names
+        attr_reader :title, :description
+
+        def name
+          s = @title
+          s += "\n#{@description}" if @description != ""
+          s
+        end
+
+        def to_s
+          @title
+        end
+      end
+    end
+  end
+end

data/lib/cucumber/core/ast/outline_step.rb

@@ -0,0 +1,51 @@
+require 'cucumber/core/ast/location'
+require 'cucumber/core/ast/describes_itself'
+require 'cucumber/core/ast/step'
+
+module Cucumber
+  module Core
+    module Ast
+
+      class OutlineStep
+        include HasLocation
+        include DescribesItself
+
+        attr_reader :language, :location, :keyword, :name, :multiline_arg
+
+        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
+
+        def gherkin_statement(statement=nil)
+          @gherkin_statement ||= statement
+        end
+
+        def to_step(row)
+          Ast::Step.new(language, location, keyword, row.expand(name), replace_multiline_arg(row))
+        end
+
+        private
+
+        def description_for_visitors
+          :outline_step
+        end
+
+        def children
+          # TODO use a null object
+          # TODO remove duplication with Step
+          # TODO spec
+          return [] unless @multiline_arg
+          [@multiline_arg]
+        end
+
+        def replace_multiline_arg(example_row)
+          return unless multiline_arg
+          multiline_arg.map { |cell| example_row.expand(cell) }
+        end
+      end
+
+    end
+  end
+end
+

data/lib/cucumber/core/ast/scenario.rb

@@ -0,0 +1,43 @@
+require 'cucumber/initializer'
+require 'cucumber/core/ast/describes_itself'
+require 'cucumber/core/ast/names'
+require 'cucumber/core/ast/empty_background'
+require 'cucumber/core/ast/location'
+
+module Cucumber
+  module Core
+    module Ast
+      class Scenario #:nodoc:
+        include Names
+        include HasLocation
+        include DescribesItself
+
+        attr_reader   :feature_tags
+        attr_accessor :feature
+        attr_reader   :comments, :tags, :keyword, :background, :title, :location, :gherkin_statement
+
+        include Cucumber.initializer(:gherkin_statement, :language, :location, :background, :comments, :tags, :feature_tags, :keyword, :title, :description, :raw_steps)
+
+        def children
+          raw_steps
+        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 += step_invocations.to_sexp if step_invocations.any?
+          sexp
+        end
+
+        private
+
+        def description_for_visitors
+          :scenario
+        end
+      end
+    end
+  end
+end

data/lib/cucumber/core/ast/scenario_outline.rb

@@ -0,0 +1,44 @@
+require 'cucumber/core/ast/names'
+require 'cucumber/core/ast/location'
+require 'cucumber/core/ast/empty_background'
+require 'cucumber/core/ast/describes_itself'
+
+module Cucumber
+  module Core
+    module Ast
+      class ScenarioOutline
+        include Names
+        include HasLocation
+        include DescribesItself
+
+        MissingExamples = Class.new(StandardError)
+
+        attr_accessor :feature
+        attr_reader :feature_tags
+
+        attr_reader :line
+        private :line
+
+        include Cucumber.initializer(:language, :location, :background, :comments, :tags, :feature_tags, :keyword, :title, :description, :steps, :examples_tables)
+
+        attr_reader :comments, :tags, :keyword, :background, :location
+
+        def gherkin_statement(node)
+          @gherkin_statement = node
+        end
+
+        private
+
+        def children
+          @steps + @examples_tables
+        end
+
+        def description_for_visitors
+          :scenario_outline
+        end
+
+      end
+
+    end
+  end
+end

data/lib/cucumber/core/ast/step.rb

@@ -0,0 +1,38 @@
+require 'cucumber/core/ast/describes_itself'
+require 'cucumber/core/ast/location'
+
+module Cucumber
+  module Core
+    module Ast
+      class Step #:nodoc:
+        include HasLocation
+        include DescribesItself
+
+        attr_reader :keyword, :name, :language, :exception, :multiline_arg
+
+        def initialize(language, location, keyword, name, multiline_arg=nil)
+          @location, @keyword, @name, @multiline_arg = location, keyword, name, multiline_arg
+        end
+
+        def gherkin_statement(statement=nil)
+          @gherkin_statement ||= statement
+        end
+
+        def to_sexp
+          [:step, line, keyword, name, (@multiline_arg.nil? ? nil : @multiline_arg.to_sexp)].compact
+        end
+
+        private
+
+        def children
+          return [] unless @multiline_arg # TODO: use a null object
+          [@multiline_arg]
+        end
+
+        def description_for_visitors
+          :step
+        end
+      end
+    end
+  end
+end

data/lib/cucumber/core/ast/tag.rb

@@ -0,0 +1,14 @@
+require 'cucumber/initializer'
+module Cucumber
+  module Core
+    module Ast
+      class Tag
+        include HasLocation
+
+        include Cucumber.initializer(:location, :name)
+
+        attr_reader :name
+      end
+    end
+  end
+end

data/lib/cucumber/core/compiler.rb

@@ -0,0 +1,136 @@
+require 'cucumber/initializer'
+require 'cucumber/core/test/case'
+require 'cucumber/core/test/step'
+
+module Cucumber
+  module Core
+    class Compiler
+      include Cucumber.initializer(:receiver)
+
+      def feature(feature)
+        compiler = FeatureCompiler.new(TestCaseBuilder.new(receiver))
+        feature.describe_to(compiler)
+        self
+      end
+
+      def done
+        receiver.done
+        self
+      end
+
+      class TestCaseBuilder
+        include Cucumber.initializer(:receiver)
+
+        def on_background_step(source)
+          background_test_steps << Test::Step.new(source)
+          self
+        end
+
+        def on_step(source)
+          test_steps << Test::Step.new(source)
+          self
+        end
+
+        def on_test_case(source)
+          Test::Case.new(test_steps, source).describe_to(receiver)
+          @test_steps = nil
+          self
+        end
+
+        private
+
+        def background_test_steps
+          @background_test_steps ||= []
+        end
+
+        def test_steps
+          @test_steps ||= background_test_steps.dup
+        end
+      end
+
+      class FeatureCompiler
+        include Cucumber.initializer(:receiver)
+
+        def feature(feature, &descend)
+          @feature = feature
+          descend.call(self)
+          self
+        end
+
+        def background(background, &descend)
+          source = [@feature, background]
+          compiler = BackgroundCompiler.new(source, receiver)
+          descend.call(compiler)
+          self
+        end
+
+        def scenario(scenario, &descend)
+          source = [@feature, scenario]
+          scenario_compiler = ScenarioCompiler.new(source, receiver)
+          descend.call(scenario_compiler)
+          receiver.on_test_case(source)
+          self
+        end
+
+        def scenario_outline(scenario_outline, &descend)
+          source = [@feature, scenario_outline]
+          compiler = ScenarioOutlineCompiler.new(source, receiver)
+          descend.call(compiler)
+          self
+        end
+      end
+
+      class ScenarioOutlineCompiler
+        include Cucumber.initializer(:source, :receiver)
+
+        def outline_step(outline_step)
+          outline_steps << outline_step
+          self
+        end
+
+        def examples_table(examples_table, &descend)
+          @examples_table = examples_table
+          descend.call(self)
+          self
+        end
+
+        def examples_table_row(row)
+          steps(row).each do |step|
+            receiver.on_step(source + [@examples_table, row, step])
+          end
+          receiver.on_test_case(source + [@examples_table, row])
+          self
+        end
+
+        private
+
+        def steps(row)
+          outline_steps.map { |s| s.to_step(row) }
+        end
+
+        def outline_steps
+          @outline_steps ||= []
+        end
+      end
+
+      class ScenarioCompiler
+        include Cucumber.initializer(:source, :receiver)
+
+        def step(step)
+          receiver.on_step(source + [step])
+          self
+        end
+      end
+
+      class BackgroundCompiler
+        include Cucumber.initializer(:source, :receiver)
+
+        def step(step)
+          receiver.on_background_step(source + [step])
+          self
+        end
+      end
+
+    end
+  end
+end

data/lib/cucumber/core/gherkin/ast_builder.rb

@@ -0,0 +1,315 @@
+require 'cucumber/initializer'
+require 'cucumber/core/ast'
+require 'cucumber/core/platform'
+
+module Cucumber
+  module Core
+    module Gherkin
+      # Builds an AST of a feature by listening to events from the
+      # Gherkin parser.
+      class AstBuilder
+
+        def initialize(path)
+          @path = path
+        end
+
+        def result
+          return nil unless @feature_builder
+          @feature_builder.result(language)
+        end
+
+        def language=(language)
+          @language = language
+        end
+
+        def uri(uri)
+          @path = uri
+        end
+
+        def feature(node)
+          @feature_builder = FeatureBuilder.new(file, node)
+        end
+
+        def background(node)
+          builder = BackgroundBuilder.new(file, node)
+          @feature_builder.background_builder = builder
+          @current = builder
+        end
+
+        def scenario(node)
+          builder = ScenarioBuilder.new(file, node)
+          @feature_builder.add_child builder
+          @current = builder
+        end
+
+        def scenario_outline(node)
+          builder = ScenarioOutlineBuilder.new(file, node)
+          @feature_builder.add_child builder
+          @current = builder
+        end
+
+        def examples(node)
+          @current.add_examples file, node
+        end
+
+        def step(node)
+          @current.add_step file, node
+        end
+
+        def eof
+        end
+
+        def syntax_error(state, event, legal_events, line)
+          # raise "SYNTAX ERROR"
+        end
+
+        private
+
+        def language
+          @language || raise("Language has not been set")
+        end
+
+        def file
+          if Cucumber::WINDOWS && !ENV['CUCUMBER_FORWARD_SLASH_PATHS']
+            @path.gsub(/\//, '\\')
+          else
+            @path
+          end
+        end
+
+        class Builder
+          include Cucumber.initializer(:file, :node)
+
+          private
+
+          def tags
+            node.tags.map do |tag|
+              Ast::Tag.new(
+                Ast::Location.new(file, tag.line),
+                tag.name)
+            end
+          end
+
+          def location
+            Ast::Location.new(file, node.line)
+          end
+
+          def comments
+            node.comments.map do |comment|
+              Ast::Comment.new(
+                Ast::Location.new(file, comment.line), 
+                comment.value
+              )
+            end
+          end
+        end
+
+        class FeatureBuilder < Builder
+          attr_accessor :background_builder
+          private :background_builder
+
+          def initialize(*)
+            super
+            @background_builder = nil
+          end
+
+          def result(language)
+            background = background(language)
+            feature = Ast::Feature.new(
+              location,
+              background,
+              comments,
+              tags,
+              node.keyword,
+              node.name.lstrip,
+              node.description.rstrip,
+              children.map { |builder| builder.result(background, language, tags) }
+            )
+            feature.gherkin_statement(node)
+            feature.language = language
+            feature
+          end
+
+          def add_child(child)
+            children << child
+          end
+
+          def children
+            @children ||= []
+          end
+
+          private
+
+          def background(language)
+            return Ast::EmptyBackground.new unless background_builder
+            @background ||= background_builder.result(language)
+          end
+        end
+
+        class BackgroundBuilder < Builder
+          def result(language)
+            Ast::Background.new(
+              node,
+              language,
+              location,
+              comments,
+              node.keyword,
+              node.name,
+              node.description,
+              steps(language)
+            )
+          end
+
+          def add_step(file, node)
+            step_builders << ScenarioBuilder::StepBuilder.new(file, node)
+          end
+
+          private
+
+          def steps(language)
+            step_builders.map { |step_builder| step_builder.result(language) }
+          end
+
+          def step_builders
+            @step_builders ||= []
+          end
+
+        end
+
+        class ScenarioBuilder < Builder
+          def result(background, language, feature_tags)
+            Ast::Scenario.new(
+              node,
+              language,
+              location,
+              background,
+              comments,
+              tags,
+              feature_tags,
+              node.keyword,
+              node.name,
+              node.description,
+              steps(language)
+            )
+          end
+
+          def add_step(file, node)
+            step_builders << StepBuilder.new(file, node)
+          end
+
+          private
+
+          def steps(language)
+            step_builders.map { |step_builder| step_builder.result(language) }
+          end
+
+          def step_builders
+            @step_builders ||= []
+          end
+
+          class StepBuilder < Builder
+            def result(language)
+              step = Ast::Step.new(
+                language,
+                location,
+                node.keyword,
+                node.name,
+                Ast::MultilineArgument.from(node.doc_string || node.rows, location)
+              )
+              step.gherkin_statement(node)
+              step
+            end
+          end
+        end
+
+        class ScenarioOutlineBuilder < Builder
+          def result(background, language, feature_tags)
+            scenario_outline = Ast::ScenarioOutline.new(
+              language,
+              location,
+              background,
+              comments,
+              tags,
+              feature_tags,
+              node.keyword,
+              node.name,
+              node.description,
+              steps(language),
+              examples_tables
+            )
+            scenario_outline.gherkin_statement(node)
+            scenario_outline
+          end
+
+          def add_examples(file, node)
+            examples_tables << ExamplesTableBuilder.new(file, node).result
+          end
+
+          def add_step(file, node)
+            step_builders << StepBuilder.new(file, node)
+          end
+
+          private
+
+          def steps(language)
+            step_builders.map { |step_builder| step_builder.result(language) }
+          end
+
+          def step_builders
+            @step_builders ||= []
+          end
+
+          def examples_tables
+            @examples_tables ||= []
+          end
+
+          class ExamplesTableBuilder < Builder
+
+            def result
+              Ast::ExamplesTable.new(
+                location,
+                comments,
+                tags,
+                node.keyword,
+                node.name,
+                node.description,
+                header,
+                example_rows
+              )
+            end
+
+            private
+
+            def header
+              row = node.rows[0]
+              Ast::ExamplesTable::Header.new(row.cells, location)
+            end
+
+            def example_rows
+              _, *raw_examples = *node.rows
+              raw_examples.each_with_index.map do |row, index|
+                header.build_row(row.cells, index + 1, location.on_line(row.line))
+              end
+            end
+
+          end
+
+          class StepBuilder < Builder
+            def result(language)
+              step = Ast::OutlineStep.new(
+                language,
+                location,
+                node.keyword,
+                node.name,
+                Ast::MultilineArgument.from(node.doc_string || node.rows, location)
+              )
+              step.gherkin_statement(node)
+              step
+            end
+          end
+        end
+
+      end
+    end
+  end
+end