mobiusloop 0.1.2

data/lib/cucumber/formatter/unicode.rb

@@ -0,0 +1,53 @@
+# Require this file if you need Unicode support.
+# Tips for improvement - esp. ruby 1.9: http://www.ruby-forum.com/topic/184730
+require 'cucumber/platform'
+require 'cucumber/formatter/ansicolor'
+
+if Cucumber::WINDOWS
+  if ENV['CUCUMBER_OUTPUT_ENCODING']
+    Cucumber::CODEPAGE = ENV['CUCUMBER_OUTPUT_ENCODING']
+  elsif `cmd /c chcp` =~ /(\d+)/
+    if [65000, 65001].include? $1.to_i
+      Cucumber::CODEPAGE = 'UTF-8'
+      ENV['ANSICON_API'] = 'ruby'
+    else
+      Cucumber::CODEPAGE = "cp#{$1.to_i}"
+    end
+  else
+    Cucumber::CODEPAGE = "cp1252"
+    STDERR.puts("WARNING: Couldn't detect your output codepage. Assuming it is 1252. You may have to chcp 1252 or SET CUCUMBER_OUTPUT_ENCODING=cp1252.")
+  end
+
+  module Cucumber
+    # @private
+    module WindowsOutput
+      def self.extended(o)
+        o.instance_eval do
+
+          def cucumber_preprocess_output(*a)
+            begin
+              a.map{|arg| arg.to_s.encode(Encoding.default_external)}
+            rescue Encoding::UndefinedConversionError => e
+              STDERR.cucumber_puts("WARNING: #{e.message}")
+              a
+            end
+          end
+
+          alias cucumber_print print
+          def print(*a)
+            cucumber_print(*cucumber_preprocess_output(*a))
+          end
+
+          alias cucumber_puts puts
+          def puts(*a)
+            cucumber_puts(*cucumber_preprocess_output(*a))
+          end
+        end
+      end
+
+      Kernel.extend(self)
+      STDOUT.extend(self)
+      STDERR.extend(self)
+    end
+  end
+end

data/lib/cucumber/formatter/usage.rb

@@ -0,0 +1,136 @@
+require 'cucumber/formatter/progress'
+require 'cucumber/step_definition_light'
+
+module Cucumber
+  module Formatter
+    class Usage < Progress
+      include Console
+
+      class StepDefKey < StepDefinitionLight
+        attr_accessor :mean_duration, :status
+      end
+
+      def initialize(runtime, path_or_io, options)
+        @runtime = runtime
+        @io = ensure_io(path_or_io)
+        @options = options
+        @stepdef_to_match = Hash.new { |h, stepdef_key| h[stepdef_key] = [] }
+        @total_duration = 0
+        @matches = {}
+        runtime.configuration.on_event :step_match do |event|
+          @matches[event.test_step.source] = event.step_match
+        end
+      end
+
+      def after_test_step(test_step, result)
+        return if HookQueryVisitor.new(test_step).hook?
+
+        step_match = @matches[test_step.source]
+        step_definition = step_match.step_definition
+        stepdef_key = StepDefKey.new(step_definition.regexp_source, step_definition.location)
+        unless @stepdef_to_match[stepdef_key].map { |key| key[:location] }.include? test_step.location
+          duration = DurationExtractor.new(result).result_duration
+
+          @stepdef_to_match[stepdef_key] << {
+            keyword: test_step.source.last.keyword,
+            step_match: step_match,
+            status: result.to_sym,
+            location: test_step.location,
+            duration: duration
+          }
+        end
+        super
+      end
+
+      private
+
+      def print_summary
+        add_unused_stepdefs
+        aggregate_info
+
+        if @options[:dry_run]
+          keys = @stepdef_to_match.keys.sort {|a,b| a.regexp_source <=> b.regexp_source}
+        else
+          keys = @stepdef_to_match.keys.sort {|a,b| a.mean_duration <=> b.mean_duration}.reverse
+        end
+
+        keys.each do |stepdef_key|
+          print_step_definition(stepdef_key)
+
+          if @stepdef_to_match[stepdef_key].any?
+            print_steps(stepdef_key)
+          else
+            @io.puts("  " + format_string("NOT MATCHED BY ANY STEPS", :failed))
+          end
+        end
+        @io.puts
+        super
+      end
+
+      def print_step_definition(stepdef_key)
+        @io.print format_string(sprintf("%.7f", stepdef_key.mean_duration), :skipped) + " " unless @options[:dry_run]
+        @io.print format_string(stepdef_key.regexp_source, stepdef_key.status)
+        if @options[:source]
+          indent = max_length - stepdef_key.regexp_source.unpack('U*').length
+          line_comment = "   # #{stepdef_key.location}".indent(indent)
+          @io.print(format_string(line_comment, :comment))
+        end
+        @io.puts
+      end
+
+      def print_steps(stepdef_key)
+        @stepdef_to_match[stepdef_key].each do |step|
+          @io.print "  "
+          @io.print format_string(sprintf("%.7f", step[:duration]), :skipped) + " " unless @options[:dry_run]
+          @io.print format_step(step[:keyword], step[:step_match], step[:status], nil)
+          if @options[:source]
+            indent = max_length - (step[:keyword].unpack('U*').length + step[:step_match].format_args.unpack('U*').length)
+            line_comment = " # #{step[:location]}".indent(indent)
+            @io.print(format_string(line_comment, :comment))
+          end
+          @io.puts
+        end
+      end
+
+      def max_length
+        [max_stepdef_length, max_step_length].compact.max
+      end
+
+      def max_stepdef_length
+        @stepdef_to_match.keys.flatten.map{|key| key.regexp_source.unpack('U*').length}.max
+      end
+
+      def max_step_length
+        @stepdef_to_match.values.to_a.flatten.map do |step|
+          step[:keyword].unpack('U*').length + step[:step_match].format_args.unpack('U*').length
+        end.max
+      end
+
+      def aggregate_info
+        @stepdef_to_match.each do |key, steps|
+          if steps.empty?
+            key.status = :skipped
+            key.mean_duration = 0
+          else
+            key.status = worst_status(steps.map{ |step| step[:status] })
+            total_duration = steps.inject(0) {|sum, step| step[:duration] + sum}
+            key.mean_duration = total_duration / steps.length
+          end
+        end
+      end
+
+      def worst_status(statuses)
+        [:passed, :undefined, :pending, :skipped, :failed].find do |status|
+          statuses.include?(status)
+        end
+      end
+
+      def add_unused_stepdefs
+        @runtime.unmatched_step_definitions.each do |step_definition|
+          stepdef_key = StepDefKey.new(step_definition.regexp_source, step_definition.location)
+          @stepdef_to_match[stepdef_key] = []
+        end
+      end
+    end
+  end
+end

data/lib/cucumber/gherkin/data_table_parser.rb

@@ -0,0 +1,31 @@
+require 'gherkin/token_scanner'
+require 'gherkin/parser'
+require 'gherkin/dialect'
+
+module Cucumber
+  module Gherkin
+    class DataTableParser
+      def initialize(builder)
+        @builder = builder
+      end
+
+      def parse(text)
+        token_scanner = ::Gherkin::TokenScanner.new(feature_header + text)
+        parser = ::Gherkin::Parser.new
+        gherkin_document = parser.parse(token_scanner)
+
+        gherkin_document[:feature][:children][0][:steps][0][:argument][:rows].each do |row|
+          @builder.row(row[:cells].map { |cell| cell[:value] })
+        end
+      end
+
+      def feature_header
+        dialect = ::Gherkin::Dialect.for('en')
+        %(#{dialect.feature_keywords[0]}:
+            #{dialect.scenario_keywords[0]}:
+              #{dialect.given_keywords[0]} x
+         )
+      end
+    end
+  end
+end

data/lib/cucumber/gherkin/formatter/ansi_escapes.rb

@@ -0,0 +1,99 @@
+module Cucumber
+module Gherkin
+  module Formatter
+    # Defines aliases for ANSI coloured output. Default colours can be overridden by defining
+    # a <tt>GHERKIN_COLORS</tt> variable in your shell, very much like how you can
+    # tweak the familiar POSIX command <tt>ls</tt> with
+    # $LSCOLORS: http://linux-sxs.org/housekeeping/lscolors.html
+    #
+    # The colours that you can change are:
+    #
+    # <tt>undefined</tt>::     defaults to <tt>yellow</tt>
+    # <tt>pending</tt>::       defaults to <tt>yellow</tt>
+    # <tt>pending_arg</tt>::   defaults to <tt>yellow,bold</tt>
+    # <tt>executing</tt>::     defaults to <tt>grey</tt>
+    # <tt>executing_arg</tt>:: defaults to <tt>grey,bold</tt>
+    # <tt>failed</tt>::        defaults to <tt>red</tt>
+    # <tt>failed_arg</tt>::    defaults to <tt>red,bold</tt>
+    # <tt>passed</tt>::        defaults to <tt>green</tt>
+    # <tt>passed_arg</tt>::    defaults to <tt>green,bold</tt>
+    # <tt>outline</tt>::       defaults to <tt>cyan</tt>
+    # <tt>outline_arg</tt>::   defaults to <tt>cyan,bold</tt>
+    # <tt>skipped</tt>::       defaults to <tt>cyan</tt>
+    # <tt>skipped_arg</tt>::   defaults to <tt>cyan,bold</tt>
+    # <tt>comment</tt>::       defaults to <tt>grey</tt>
+    # <tt>tag</tt>::           defaults to <tt>cyan</tt>
+    #
+    # For instance, if your shell has a black background and a green font (like the
+    # "Homebrew" settings for OS X' Terminal.app), you may want to override passed
+    # steps to be white instead of green. Examples:
+    #
+    #   export GHERKIN_COLORS="passed=white"
+    #   export GHERKIN_COLORS="passed=white,bold:passed_arg=white,bold,underline"
+    #
+    # (If you're on Windows, use SET instead of export).
+    # To see what colours and effects are available, just run this in your shell:
+    #
+    #   ruby -e "require 'rubygems'; require 'term/ansicolor'; puts Term::ANSIColor.attributes"
+    #
+    # Although not listed, you can also use <tt>grey</tt>
+    module AnsiEscapes
+      COLORS = {
+        'black'   => "\e[30m",
+        'red'     => "\e[31m",
+        'green'   => "\e[32m",
+        'yellow'  => "\e[33m",
+        'blue'    => "\e[34m",
+        'magenta' => "\e[35m",
+        'cyan'    => "\e[36m",
+        'white'   => "\e[37m",
+        'grey'    => "\e[90m",
+        'bold'    => "\e[1m"
+      }
+
+      ALIASES = Hash.new do |h,k|
+        if k.to_s =~ /(.*)_arg/
+          h[$1] + ',bold'
+        end
+      end.merge({
+        'undefined' => 'yellow',
+        'pending'   => 'yellow',
+        'executing' => 'grey',
+        'failed'    => 'red',
+        'passed'    => 'green',
+        'outline'   => 'cyan',
+        'skipped'   => 'cyan',
+        'comments'  => 'grey',
+        'tag'       => 'cyan'
+      })
+
+      if ENV['GHERKIN_COLORS'] # Example: export GHERKIN_COLORS="passed=red:failed=yellow"
+        ENV['GHERKIN_COLORS'].split(':').each do |pair|
+          a = pair.split('=')
+          ALIASES[a[0]] = a[1]
+        end
+      end
+
+      ALIASES.keys.each do |key|
+        define_method(key) do
+          ALIASES[key].split(',').map{|color| COLORS[color]}.join('')
+        end
+
+        define_method("#{key}_arg") do
+          ALIASES["#{key}_arg"].split(',').map{|color| COLORS[color]}.join('')
+        end
+      end
+      
+      def reset
+        "\e[0m"
+      end
+
+      def up(n)
+        "\e[#{n}A"
+      end
+
+      extend self
+    end
+  end
+end
+end

data/lib/cucumber/gherkin/formatter/escaping.rb

@@ -0,0 +1,17 @@
+module Cucumber
+module Gherkin
+  module Formatter
+    module Escaping
+      # Escapes a pipes and backslashes:
+      #
+      # * | becomes \|
+      # * \ becomes \\
+      #
+      # This is used in the pretty formatter.
+      def escape_cell(s)
+        s.gsub(/\\(?!\|)/, "\\\\\\\\").gsub(/\n/, "\\n").gsub(/\|/, "\\|")
+      end
+    end
+  end
+end
+end

data/lib/cucumber/gherkin/i18n.rb

@@ -0,0 +1,15 @@
+module Cucumber
+  module Gherkin
+    module I18n
+      class << self
+        def code_keyword_for(gherkin_keyword)
+          gherkin_keyword.gsub(/[\s',!]/, '').strip
+        end
+
+        def code_keywords_for(gherkin_keywords)
+          gherkin_keywords.reject { |kw| kw == '* ' }.map { |kw| code_keyword_for(kw) }
+        end
+      end
+    end
+  end
+end

data/lib/cucumber/gherkin/steps_parser.rb

@@ -0,0 +1,31 @@
+require 'gherkin/token_scanner'
+require 'gherkin/token_matcher'
+require 'gherkin/parser'
+require 'gherkin/dialect'
+
+module Cucumber
+  module Gherkin
+    class StepsParser
+      def initialize(builder, language)
+        @builder = builder
+        @language = language
+      end
+
+      def parse(text)
+        dialect = ::Gherkin::Dialect.for(@language)
+        token_matcher = ::Gherkin::TokenMatcher.new(@language)
+        token_scanner = ::Gherkin::TokenScanner.new(feature_header(dialect) + text)
+        parser = ::Gherkin::Parser.new
+        gherkin_document = parser.parse(token_scanner, token_matcher)
+
+        @builder.steps(gherkin_document[:feature][:children][0][:steps])
+      end
+
+      def feature_header(dialect)
+        %(#{dialect.feature_keywords[0]}:
+            #{dialect.scenario_keywords[0]}:
+         )
+      end
+    end
+  end
+end

data/lib/cucumber/hooks.rb

@@ -0,0 +1,99 @@
+require 'pathname'
+require 'cucumber/core/ast/location'
+require 'cucumber/core/test/around_hook'
+
+module Cucumber
+
+  # Hooks quack enough like `Cucumber::Core::Ast` source nodes that we can use them as
+  # source for test steps
+  module Hooks
+
+    class << self
+      def before_hook(source, location, &block)
+        build_hook_step(source, location, block, BeforeHook, Core::Test::UnskippableAction)
+      end
+
+      def after_hook(source, location, &block)
+        build_hook_step(source, location, block, AfterHook, Core::Test::UnskippableAction)
+      end
+
+      def after_step_hook(source, location, &block)
+        raise ArgumentError unless source.last.kind_of?(Core::Ast::Step)
+        build_hook_step(source, location, block, AfterStepHook, Core::Test::Action)
+      end
+
+      def around_hook(source, &block)
+        Core::Test::AroundHook.new(&block)
+      end
+
+      private
+
+      def build_hook_step(source, location, block, hook_type, action_type)
+        action = action_type.new(location, &block)
+        hook = hook_type.new(action.location)
+        Core::Test::Step.new(source + [hook], action)
+      end
+    end
+
+    class AfterHook
+      attr_reader :location
+
+      def initialize(location)
+        @location = location
+      end
+
+      def name
+        "After hook"
+      end
+
+      def match_locations?(queried_locations)
+        queried_locations.any? { |other_location| other_location.match?(location) }
+      end
+
+      def describe_to(visitor, *args)
+        visitor.after_hook(self, *args)
+      end
+    end
+
+    class BeforeHook
+      attr_reader :location
+
+      def initialize(location)
+        @location = location
+      end
+
+      def name
+        "Before hook"
+      end
+
+      def match_locations?(queried_locations)
+        queried_locations.any? { |other_location| other_location.match?(location) }
+      end
+
+      def describe_to(visitor, *args)
+        visitor.before_hook(self, *args)
+      end
+    end
+
+    class AfterStepHook
+      attr_reader :location
+
+      def initialize(location)
+        @location = location
+      end
+
+      def name
+        "AfterStep hook"
+      end
+
+      def match_locations?(queried_locations)
+        queried_locations.any? { |other_location| other_location.match?(location) }
+      end
+
+      def describe_to(visitor, *args)
+        visitor.after_step_hook(self, *args)
+      end
+    end
+
+  end
+end