Simpler formatter

bin/cuke

@@ -10,153 +10,150 @@ require 'cucumber/formatter/ansicolor'
 
 module Cucumber
 
-  require 'ansi' # gem install ansi
-  class PrettyPrinter
+  class ProgressConsoleReport
     include Cucumber::Formatter::ANSIColor
 
-    def feature(feature, *)
-      for_new(:feature, feature) do
-        print_keyword feature, 1
-      end
+    def before_test_case(test_case)
+      test_case.describe_source_to feature_printer
+      print "  #{test_case.name} "
+      print green('(')
     end
 
-    def background(background, *)
-      for_new(:background, background) do
-        print_keyword background, 2
-      end
+    def after_test_case(test_case, result)
+      result.describe_to ResultPrinter.new(") ")
+      result.describe_to ResultPrinter.new(result.to_s)
+      result.describe_to summary, test_case, result
+      puts
     end
 
-    def scenario(scenario, *)
-      for_new(:scenario, scenario) do
-        print_keyword scenario, 2
-      end
+    def before_test_step(step)
     end
 
-    def scenario_outline(scenario_outline, *)
-      for_new(:scenario_outline, scenario_outline) do
-        print_keyword scenario_outline, 2
-        # TODO: print steps
-      end
+    def after_test_step(step, result)
+      result.describe_to ResultPrinter.new(":")
     end
 
-    def examples_table(examples_table, *)
-      for_new(:examples_table, examples_table) do
-        print_keyword examples_table, 3
-      end
+    def after_suite
+      summary.print
     end
 
-    def test_case(*args)
-      yield
-    end
+    private
 
-    def examples_table_row(row, *)
-      puts row.to_s
+    def feature_printer
+      @feature_printer ||= FeaturePrinter.new
     end
 
-    def step(step, result=nil)
-      return unless result
-      indent = "      "
-      result.describe_to(self, indent + "#{format_step(step)} #{result}")
-      print "\n"
+    def summary
+      @summary ||= Summary.new
     end
 
-    def hook(result=nil)
-      return unless result
-      return unless result.failed?
-      indent = "      "
-      result.describe_to(self, indent + "#{result} (hook)")
-    end
+    class Summary
+      def initialize
+        @failed = []
+      end
 
-    def duration(duration, *)
-      # print grey(" (#{duration} ms)")
-    end
+      def failed(test_case, result)
+        @failed << test_case
+      end
 
-    def exception(exception, *args)
-      indent = "        "
-      puts
-      puts red(indent + exception.message)
-      puts red(exception.backtrace.join("\n"))
-      puts
-    end
+      def exception(exception, test_case, result)
+      end
 
-    def unknown
-    end
+      def duration(*)
+      end
 
-    def failed(text)
-      print super(text)
-    end
+      def passed(test_case, result)
+      end
 
-    def skipped(text)
-      print super(text)
-    end
+      def print
+        if @failed.any?
+          puts
+          puts red("Failed scenarios:")
+          @failed.each do |test_case|
+            puts red(test_case.name) # TODO: expose location of Test::Case
+          end
+        end
+      end
+
+      private
 
-    def passed(text)
-      print super(text)
+      def red(string)
+        "\e[31m#{string}\e[0m"
+      end
     end
 
-    private
+    class FeaturePrinter
+      def feature(feature)
+        return if feature == @current_feature
+        @current_feature = feature
+        puts
+        puts feature.title
+      end
 
-    def print_keyword(node, indent_size)
-      indent = ' ' * indent_size * 2
-      puts
-      puts "#{indent}#{node.keyword}: #{node.name}"
-    end
+      def scenario(*)
+      end
 
-    def for_new(node_type, value)
-      @current ||= {}
-      return if @current[node_type] == value
-      @current[node_type] = value
-      yield
-    end
+      def scenario_outline(*)
+      end
 
-    def color(result, text)
-      result.describe_to(self, text)
-    end
+      def examples_table(*)
+      end
 
-    def format_step(step)
-      "#{step.keyword}#{step.name}"
+      def examples_table_row(*)
+      end
     end
 
-    attr_reader :current_feature
-  end
+    class ResultPrinter
+      def initialize(character)
+        @character = character
+      end
 
-  require 'cucumber/core/test/result'
-  class PrettyConsoleReport
-    def initialize(printer)
-      @printer = printer
-      @summary = Cucumber::Core::Test::Result::Summary.new
-    end
+      def passed
+        print green(@character)
+      end
 
-    def before_test_suite(test_suite)
-    end
+      def failed
+        print red(@character)
+      end
 
-    def before_test_case(test_case)
-    end
+      def skipped
+        print cyan(@character)
+      end
 
-    def before_test_step(step)
-      step.describe_source_to(@printer)
-    end
+      def duration(ms)
+      end
 
-    def after_test_step(step, result)
-      step.describe_source_to(@printer, result)
-    end
+      def exception(exception)
+        puts
+        puts red(exception.message)
+        puts red(exception.backtrace.join("\n"))
+        puts
+      end
 
-    def after_test_case(test_case, result)
-      result.describe_to(@summary)
-    end
+      private
+
+      def green(string)
+        "\e[32m#{string}\e[0m"
+      end
 
-    def after_test_suite(test_suite, result)
-      @printer.print(@summary.to_s)
+      def red(string)
+        "\e[31m#{string}\e[0m"
+      end
+
+      def cyan(string)
+        "\e[36m#{string}\e[0m"
+      end
     end
 
   end
 
   features_glob = ARGV[0] || 'features/**/*.feature'
   feature_files = Dir[features_glob].reject { |f| f =~ /iso-8859-1/ }
-  #feature_files = Dir["fixtures/self_test/features/outline_sample.feature"]
-  #support_files = Dir['fixtures/self_test/features/**/*.rb']
+  puts "Running features:"
+  p feature_files
 
-  report = PrettyConsoleReport.new(PrettyPrinter.new)
+  # report = PrettyConsoleReport.new(PrettyPrinter.new)
+  report = ProgressConsoleReport.new
 
   require 'cucumber/core'
   extend Cucumber::Core
@@ -210,7 +207,7 @@ module Cucumber
       end
 
       def accept_hook?(hook)
-        true
+        hook.tag_expressions.any? { |expression| @test_case.match_tags?(expression) }
       end
 
       def language
@@ -220,5 +217,6 @@ module Cucumber
   end
 
   mappings = ClassicMappings.new
-  execute(features, mappings, report)
+  execute features, mappings, report
+  report.after_suite
 end