cucumber-core 0.1.0

data/lib/cucumber/core/platform.rb

@@ -0,0 +1,30 @@
+# Detect the platform we're running on so we can tweak behaviour
+# in various places.
+require 'rbconfig'
+
+module Cucumber
+  unless defined?(Cucumber::VERSION)
+    VERSION       = '2.0'
+    BINARY        = File.expand_path(File.dirname(__FILE__) + '/../../bin/cucumber')
+    LIBDIR        = File.expand_path(File.dirname(__FILE__) + '/../../lib')
+    JRUBY         = defined?(JRUBY_VERSION)
+    IRONRUBY      = defined?(RUBY_ENGINE) && RUBY_ENGINE == "ironruby"
+    WINDOWS       = RbConfig::CONFIG['host_os'] =~ /mswin|mingw/
+    OS_X          = RbConfig::CONFIG['host_os'] =~ /darwin/
+    WINDOWS_MRI   = WINDOWS && !JRUBY && !IRONRUBY
+    RAILS         = defined?(Rails)
+    RUBY_BINARY   = File.join(RbConfig::CONFIG['bindir'], RbConfig::CONFIG['ruby_install_name'])
+    RUBY_2_0      = RUBY_VERSION =~ /^2\.0/
+    RUBY_1_9      = RUBY_VERSION =~ /^1\.9/
+
+    class << self
+      attr_accessor :use_full_backtrace
+
+      # @private
+      def file_mode(m, encoding="UTF-8")
+        "#{m}:#{encoding}"
+      end
+    end
+    self.use_full_backtrace = false
+  end
+end

data/lib/cucumber/core/test/case.rb

@@ -0,0 +1,143 @@
+require 'cucumber/initializer'
+require 'cucumber/core/test/result'
+
+module Cucumber
+  module Core
+    module Test
+      class Case
+        include Cucumber.initializer(:test_steps, :source, :around_hooks)
+        attr_reader :source
+
+        def initialize(test_steps, source, around_hooks = [])
+          super(test_steps, source, around_hooks)
+        end
+
+        def describe_to(visitor, *args)
+          visitor.test_case(self, *args) do |child_visitor=visitor|
+            compose_around_hooks(child_visitor, *args) do
+              test_steps.each do |test_step|
+                test_step.describe_to(child_visitor, *args)
+              end
+            end
+          end
+          self
+        end
+
+        def describe_source_to(visitor, *args)
+          source.each do |node|
+            node.describe_to(visitor, *args)
+          end
+          self
+        end
+
+        def with_steps(test_steps)
+          self.class.new(test_steps, source, around_hooks)
+        end
+
+        def with_around_hooks(around_hooks)
+          self.class.new(test_steps, source, around_hooks)
+        end
+
+        def name
+          @name ||= NameBuilder.new(self).result
+        end
+
+        def tags
+          @tags ||= TagCollector.new(self).result
+        end
+
+        require 'gherkin/tag_expression'
+        def match_tags?(*expressions)
+          ::Gherkin::TagExpression.new(expressions.flatten).evaluate(tags.map {|t| ::Gherkin::Formatter::Model::Tag.new(t.name, t.line) })
+        end
+
+        def match_name?(name_regexp)
+          source.any? { |node| node.respond_to?(:name) && node.name =~ name_regexp }
+        end
+
+        def language
+          feature.language
+        end
+
+        def location
+          source.last.location
+        end
+
+        def match_locations?(queried_locations)
+          return true if source.any? { |s| s.match_locations?(queried_locations) }
+          test_steps.any? { |node| node.match_locations? queried_locations }
+        end
+
+        def inspect
+          "<#{self.class}: #{location}>"
+        end
+
+        private
+
+        def compose_around_hooks(visitor, *args, &block)
+          around_hooks.reverse.reduce(block) do |continue, hook|
+            -> { hook.describe_to(visitor, *args, &continue) }
+          end.call
+        end
+
+        def feature
+          source.first
+        end
+
+        class NameBuilder
+          attr_reader :result
+
+          def initialize(test_case)
+            test_case.describe_source_to self
+          end
+
+          def feature(*)
+            self
+          end
+
+          def scenario(scenario)
+            @result = "#{scenario.keyword}: #{scenario.name}"
+            self
+          end
+
+          def scenario_outline(outline)
+            @result = "#{outline.keyword}: #{outline.name}"
+            self
+          end
+
+          def examples_table(table)
+            name = table.name.strip
+            name = table.keyword if name.length == 0
+            @result << ", #{name}"
+            self
+          end
+
+          def examples_table_row(row)
+            @result << " (row #{row.number})"
+            self
+          end
+        end
+
+        class TagCollector
+          attr_reader :result
+
+          def initialize(test_case)
+            @result = []
+            test_case.describe_source_to self
+          end
+
+          [:feature, :scenario, :scenario_outline, :examples_table].each do |node_name|
+            define_method(node_name) do |node|
+              @result += node.tags
+              self
+            end
+          end
+
+          def examples_table_row(*)
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/cucumber/core/test/filters.rb

@@ -0,0 +1,48 @@
+require 'cucumber/core/test/filters/tag_filter'
+module Cucumber
+  module Core
+    module Test
+
+      class LocationsFilter
+        def initialize(locations, receiver)
+          @receiver = receiver
+          @locations = locations
+        end
+
+        def test_case(test_case)
+          if test_case.match_locations?(@locations)
+            test_case.describe_to @receiver
+          end
+          self
+        end
+
+        def done
+          @receiver.done
+          self
+        end
+      end
+
+      class NameFilter
+        include Cucumber.initializer(:name_regexps, :receiver)
+
+        def test_case(test_case)
+          if accept?(test_case)
+            test_case.describe_to(receiver)
+          end
+          self
+        end
+
+        def done
+          @receiver.done
+          self
+        end
+
+        private
+
+        def accept?(test_case)
+          name_regexps.empty? || name_regexps.any? { |name_regexp| test_case.match_name?(name_regexp) }
+        end
+      end
+    end
+  end
+end

data/lib/cucumber/core/test/filters/tag_filter.rb

@@ -0,0 +1,110 @@
+module Cucumber
+  module Core
+    module Test
+      class TagFilter
+        include Cucumber.initializer(:filter_expressions, :receiver)
+
+        def test_case(test_case)
+          test_cases << test_case
+          if test_case.match_tags?(filter_expressions)
+            test_case.describe_to(receiver)
+          end
+          self
+        end
+
+        def done
+          tag_limits.enforce(test_cases)
+          receiver.done
+          self
+        end
+
+        private
+        def test_cases
+          @test_cases ||= TestCases.new
+        end
+
+        def tag_limits
+          @tag_limits ||= TagLimits.new(filter_expressions)
+        end
+
+        class TestCases
+          attr_reader :test_cases_by_tag_name
+          private :test_cases_by_tag_name
+          def initialize
+            @test_cases_by_tag_name = Hash.new { [] }
+          end
+
+          def <<(test_case)
+            test_case.tags.each do |tag|
+              test_cases_by_tag_name[tag.name] += [test_case]
+            end
+            self
+          end
+
+          def with_tag_name(tag_name)
+            test_cases_by_tag_name[tag_name]
+          end
+        end
+
+        class TagLimits
+          TAG_MATCHER = /^
+            (?:~)?                 #The tag negation symbol "~". This is optional and not captured.
+            (?<tag_name>\@[\w\d]+) #Captures the tag name including the "@" symbol.
+            \:                     #The seperator, ":", between the tag name and the limit.
+            (?<limit>\d+)          #Caputres the limit number.
+          $/x
+
+          attr_reader :limit_list
+          private :limit_list
+          def initialize(filter_expressions)
+            @limit_list = Array(filter_expressions).flat_map do |raw_expression|
+              raw_expression.split(/\s*,\s*/)
+            end.map do |filter_expression|
+              TAG_MATCHER.match(filter_expression)
+            end.compact.each_with_object({}) do |matchdata, limit_list|
+              limit_list[matchdata[:tag_name]] = Integer(matchdata[:limit])
+            end
+          end
+
+          def enforce(test_cases)
+            limit_breaches = limit_list.reduce([]) do |breaches, (tag_name, limit)|
+              tag_count = test_cases.with_tag_name(tag_name).count
+              if tag_count > limit
+                tag_locations = test_cases.with_tag_name(tag_name).map(&:location)
+                breaches << TagLimitBreach.new(
+                  tag_count,
+                  limit,
+                  tag_name,
+                  tag_locations
+                )
+              end
+              breaches
+            end
+            raise TagExcess.new(limit_breaches) if limit_breaches.any?
+            self
+          end
+        end
+
+        TagLimitBreach = Struct.new(
+          :tag_count,
+          :tag_limit,
+          :tag_name,
+          :tag_locations
+        ) do
+
+          def message
+            "#{tag_name} occurred #{tag_count} times, but the limit was set to #{tag_limit}\n  " +
+              tag_locations.map(&:to_s).join("\n  ")
+          end
+          alias :to_s :message
+        end
+
+        class TagExcess < StandardError
+          def initialize(limit_breaches)
+            super(limit_breaches.map(&:to_s).join("\n"))
+          end
+        end
+      end
+    end
+  end
+end

data/lib/cucumber/core/test/hook_compiler.rb

@@ -0,0 +1,109 @@
+require 'cucumber/initializer'
+
+module Cucumber
+  module Core
+    module Test
+      class HookStep
+        def initialize(source, &block)
+          @mapping = Test::Mapping.new(&block)
+          @source = source
+        end
+
+        def describe_to(visitor, *args)
+          visitor.test_step(self, *args)
+        end
+
+        def describe_source_to(visitor, *args)
+          visitor.hook(*args)
+        end
+
+        def execute
+          @mapping.execute
+        end
+
+        def skip
+          execute
+        end
+
+        def map
+          self
+        end
+
+        def match_locations?(locations)
+          false
+        end
+
+        def inspect
+          "#{self.class}"
+        end
+      end
+
+      class HookCompiler
+        include Cucumber.initializer(:mappings, :receiver)
+
+        def done
+          receiver.done
+          self
+        end
+
+        def test_case(test_case, &descend)
+          @before_hooks, @after_hooks, @around_hooks, @steps = [], [], [], []
+          mapper = HookMapper.new(self, test_case.source)
+          test_case.describe_to mappings, mapper
+          descend.call
+          test_case.
+            with_steps(@before_hooks + @steps + @after_hooks).
+            with_around_hooks(@around_hooks).
+            describe_to(receiver)
+        end
+
+        def before_hook(hook)
+          @before_hooks << hook
+        end
+
+        def after_hook(hook)
+          @after_hooks << hook
+        end
+
+        def around_hook(hook)
+          @around_hooks << hook
+        end
+
+        def test_step(step)
+          @steps << step
+        end
+
+        class HookMapper
+          include Cucumber.initializer(:compiler, :source)
+
+          def before(&block)
+            compiler.before_hook HookStep.new(source, &block)
+          end
+
+          def after(&block)
+            compiler.after_hook HookStep.new(source, &block)
+          end
+
+          def around(&block)
+            compiler.around_hook AroundHook.new(source, &block)
+          end
+
+          class AroundHook
+            def initialize(source, &block)
+              @source = source
+              @block = block
+            end
+
+            def call(continue)
+              @block.call(continue)
+            end
+
+            def describe_to(visitor, *args, &continue)
+              visitor.around_hook(self, *args, &continue)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/cucumber/core/test/mapper.rb

@@ -0,0 +1,56 @@
+require 'cucumber/initializer'
+module Cucumber
+  module Core
+    module Test
+      class Mapper
+        include Cucumber.initializer(:mappings, :runner)
+
+        def test_case(test_case, &descend)
+          mapper = CaseMapper.new(mappings)
+          descend.call(mapper)
+          test_case.with_steps(mapper.test_steps).describe_to(runner)
+          self
+        end
+
+        def done
+          runner.done
+          self
+        end
+
+        class CaseMapper
+          include Cucumber.initializer(:mappings)
+
+          attr_reader :test_steps
+
+          def initialize(*)
+            super
+            @test_steps = []
+          end
+
+          def test_step(test_step)
+            mapper = StepMapper.new(test_step)
+            test_step.describe_to(mappings, mapper)
+            test_steps << mapper.mapped_test_step
+          end
+
+        end
+
+        class StepMapper
+          include Cucumber.initializer(:test_step)
+
+          attr_reader :mapped_test_step
+
+          def initialize(*)
+            super
+            @mapped_test_step = test_step
+          end
+
+          def map(&block)
+            @mapped_test_step = test_step.map(&block)
+          end
+        end
+
+      end
+    end
+  end
+end