gurke 1.0.1 → 2.0.0.dev.1.b17

data/lib/gurke/dsl.rb

@@ -0,0 +1,45 @@
+module Gurke
+  #
+  module DSL
+    def step(pattern, method_name = nil, opts = {}, &block)
+      if method_name.is_a?(Hash) && opts.empty?
+        method_name, opts = nil, method_name
+      end
+
+      if method_name && block_given?
+        raise ArgumentError.new <<-EOF.strip
+          You can either specify a method name or given a block, not both.
+        EOF
+      end
+
+      _define_step(pattern, method_name, opts, &block)
+    end
+
+    def _define_step(pattern, method_name, opts, &block)
+      step = StepDefinition.new(pattern, opts)
+
+      define_method("match: #{step.method_name}") do |name, s = nil|
+        step.match(name, s)
+      end
+
+      if block_given?
+        define_method("#{step.method_name}", &block)
+      elsif method_name
+        alias_method "#{step.method_name}", method_name
+      end
+    end
+
+    # rubocop:disable MethodName
+    def Given(pattern, method_name = nil, opts = {}, &block)
+      step pattern, method_name, opts.merge(type: :given), &block
+    end
+
+    def When(pattern, method_name = nil, opts = {}, &block)
+      step pattern, method_name, opts.merge(type: :when), &block
+    end
+
+    def Then(pattern, method_name = nil, opts = {}, &block)
+      step pattern, method_name, opts.merge(type: :then), &block
+    end
+  end
+end

data/lib/gurke/feature.rb

@@ -0,0 +1,55 @@
+module Gurke
+  #
+  class Feature
+    #
+    # Return path to file containing this feature.
+    #
+    # @return [String] File path.
+    #
+    attr_reader :file
+
+    # Return line number where this feature is defined.
+    #
+    # @return [Fixnum] Line number.
+    #
+    attr_reader :line
+
+    attr_reader :tags
+
+    # @api private
+    attr_reader :raw
+
+    # @api private
+    def initialize(file, line, tags, raw)
+      @file, @line, @tags, @raw = file, line, tags, raw
+    end
+
+    def name
+      raw.name
+    end
+
+    def description
+      raw.description
+    end
+
+    # Return list of scenarios this feature specifies.
+    #
+    # @return [Array<Scenario>] Scenarios.
+    #
+    def scenarios
+      @scenarios ||= []
+    end
+
+    def backgrounds
+      @backgrounds ||= []
+    end
+
+    # Return name of this feature.
+    #
+    # @return [String] Feature name.
+    #
+    def name
+      raw.name
+    end
+  end
+end

data/lib/gurke/reporter.rb

@@ -0,0 +1,98 @@
+require 'colorize'
+
+# Colorize colors:
+#   :black, :red, :green, :yellow, :blue,
+#   :magenta, :cyan, :white, :default, :light_black,
+#   :light_red, :light_green, :light_yellow, :light_blue,
+#   :light_magenta, :light_cyan, :light_white
+
+module Gurke
+  #
+  class Reporter
+    def start_features(*)
+    end
+
+    def start_feature(feature)
+      io.puts "#{yellow('Feature')}: #{feature.name}"
+      io.puts '  ' + light_black(feature.description.split("\n").join("\n  "))
+      io.puts
+    end
+
+    def start_scenario(scenario, feature)
+      io.puts "  #{yellow('Scenario')}: #{scenario.name}"
+      io.puts light_black('    Background:') if feature.backgrounds.any?
+    end
+
+    def start_background(*)
+      @background = true
+    end
+
+    def finish_background(*)
+      @background = false
+    end
+
+    def start_step(step, *)
+      io.print '  ' if @background
+      io.print '    '
+      io.print yellow(step.keyword)
+      io.print step.name.gsub(/"(.*?)"/, cyan('\0'))
+    end
+
+    def finish_step(step, *)
+      case step.state
+        when :pending
+          print_braces yellow('pending')
+        when :failed
+          print_braces red('failure')
+          io.puts
+          io.puts red("      #{step.exception.class}:")
+
+          msg = step.exception.message.split("\n").join("\n          ")
+          io.puts red("        #{msg}")
+
+          io.puts red("      #{step.exception.backtrace.join("\n      ")}")
+        when :success
+          print_braces green('success')
+        else
+          print_braces cyan('skipped')
+      end
+      io.puts
+      io.flush
+    end
+
+    def finish_scenario(*)
+      io.puts
+    end
+
+    def finish_feature(*)
+      io.puts
+    end
+
+    def finish_features(features)
+      scenarios = features.map(&:scenarios).flatten
+
+      io.puts "  #{scenarios.size} scenarios: "\
+              "#{scenarios.select(&:failed?).size} failing, "\
+              "#{scenarios.select(&:pending?).size} pending"
+      io.puts
+    end
+
+    private
+
+    def print_braces(str)
+      io.print " (#{str})"
+    end
+
+    def io
+      $stdout
+    end
+
+    [:black, :red, :green, :yellow, :blue,
+     :magenta, :cyan, :white, :default, :light_black,
+     :light_red, :light_green, :light_yellow, :light_blue,
+     :light_magenta, :light_cyan, :light_white].each do |color|
+
+      define_method(color){|str|  io.tty? ? str.send(color) : str }
+    end
+  end
+end

data/lib/gurke/rspec.rb

@@ -0,0 +1,5 @@
+require 'rspec/expectations'
+
+Gurke.configure do |c|
+  c.include RSpec::Matchers
+end

data/lib/gurke/runner.rb

@@ -0,0 +1,156 @@
+module Gurke
+  #
+  class Runner
+    attr_reader :builder
+    attr_reader :files
+    attr_reader :options
+
+    def initialize(files, options = {})
+      @options = options
+      @files   = files
+      @builder = Builder.new options
+    end
+
+    def reporter
+      @reporter ||= Reporter.new
+    end
+
+    def run
+      files.each{|f| builder.parse(f) }
+
+      with_hooks(:features, nil, nil) do
+        run_features builder.features
+      end
+
+      !builder.features
+        .map(&:scenarios)
+        .flatten
+        .any?{|s| s.failed? || s.pending? }
+    end
+
+    def run_features(features)
+      reporter.start_features(features)
+
+      features.each do |feature|
+        run_feature(feature)
+      end
+
+      reporter.finish_features(features)
+    end
+
+    def run_feature(feature)
+      reporter.start_feature(feature)
+
+      feature.scenarios.each do |scenario|
+        run_scenario(scenario, feature)
+      end
+
+      reporter.finish_feature(feature)
+    end
+
+    def run_scenario(scenario, feature)
+      reporter.start_scenario(scenario, feature)
+
+      world = world_for(scenario, feature)
+
+      with_hooks(:scenario, scenario, world) do
+        feature.backgrounds.each do |b|
+          run_background(b, scenario, feature, world)
+        end
+        scenario.steps.each{|s| run_step(s, scenario, feature, world) }
+      end
+
+      reporter.finish_scenario(scenario, feature)
+    end
+
+    def run_background(background, scenario, feature, world)
+      reporter.start_background(background)
+
+      background.steps.each{|s| run_step(s, scenario, feature, world) }
+
+      reporter.finish_background(background)
+    end
+
+    def run_step(step, scenario, feature, world)
+      reporter.start_step(step, scenario, feature)
+
+      result = nil
+      with_filtered_backtrace do
+        match = Steps.find_step(step, world, step.type)
+
+        if scenario.pending? || scenario.failed?
+          result = StepResult.new(step, :skipped)
+          return
+        end
+
+        m = world.method(match.method_name)
+        world.send match.method_name, *(match.params + [step])[0...m.arity]
+      end
+
+      result = StepResult.new(step, :success)
+    rescue StepPending => e
+      scenario.pending! e
+      result = StepResult.new(step, :pending, e)
+    rescue => e
+      scenario.failed! e
+      result = StepResult.new(step, :failed, e)
+    ensure
+      reporter.finish_step(result, scenario, feature)
+    end
+
+    def with_hooks(scope, _context, world, &block)
+      Configuration::BEFORE_HOOKS.for(scope).each do |hook|
+        hook.run(world)
+      end
+      Configuration::AROUND_HOOKS.for(scope).reduce(block) do |blk, hook|
+        proc { hook.run(world, blk) }
+      end.call
+      Configuration::AFTER_HOOKS.for(scope).each do |hook|
+        hook.run(world)
+      end
+    end
+
+    def world_for(scenario, _feature)
+      scenario.send(:world)
+    end
+
+    def with_filtered_backtrace
+      yield
+    rescue => e
+      unless options[:backtrace]
+        base = File.expand_path(Gurke.root.dirname)
+        e.backtrace.select!{|l| File.expand_path(l)[0...base.size] == base }
+      end
+      raise
+    end
+
+    #
+    class StepResult
+      attr_reader :step, :exception, :state
+
+      def initialize(step, state, err = nil)
+        @step, @state, @exception = step, state, err
+      end
+
+      Gurke::Step.public_instance_methods(false).each do |m|
+        define_method(m){|*args| step.send m, *args }
+      end
+
+      def failed?
+        @state == :failed
+      end
+
+      def pending?
+        @state == :pending
+      end
+
+      def skipped?
+        @state == :skipped
+      end
+
+      def success?
+        @state == :success
+      end
+    end
+  end
+end

data/lib/gurke/scenario.rb

@@ -0,0 +1,84 @@
+module Gurke
+  #
+  class Scenario
+    #
+    # Return path to file containing this scenario.
+    #
+    # @return [String] File path.
+    #
+    attr_reader :file
+
+    # Return line number where the scenario is defined.
+    #
+    # @return [Fixnum] Line number.
+    #
+    attr_reader :line
+
+    attr_reader :tags
+
+    # @api private
+    attr_reader :raw
+
+    # @api private
+    def initialize(file, line, tags, raw)
+      @file, @line, @tags, @raw = file, line, tags, raw
+    end
+
+    # Return list of this scenario's steps.
+    #
+    # This does not include background steps.
+    #
+    # @return [Array<Step>] Steps.
+    #
+    def steps
+      @steps ||= []
+    end
+
+    # Return name of the scenario.
+    #
+    # @return [String] Scenario name.
+    #
+    def name
+      raw.name
+    end
+
+    def pending?
+      @state == :pending
+    end
+
+    def failed?
+      @state == :failed
+    end
+
+    attr_reader :exception
+
+    # @api private
+    def failed!(error)
+      @exception = error
+      @state     = :failed
+    end
+
+    # @api private
+    def pending!(error)
+      return if failed?
+
+      @exception = error
+      @state     = :pending
+    end
+
+    private
+
+    def world
+      @world ||= begin
+        cls = Class.new
+        cls.send :include, Gurke.world
+
+        Gurke.config.inclusions.each do |incl|
+          cls.send :include, incl.mod
+        end
+        cls.send :include, Gurke::Steps
+        cls.new
+      end
+    end
+  end
+end