stefl-cucumber 0.10.1

data/lib/cucumber/formatter/summary.rb

@@ -0,0 +1,35 @@
+module Cucumber
+  module Formatter
+    module Summary
+
+      def scenario_summary(step_mother, &block)
+        scenarios_proc = lambda{|status| step_mother.scenarios(status)}
+        dump_count(step_mother.scenarios.length, "scenario") + dump_status_counts(scenarios_proc, &block)
+      end
+
+      def step_summary(step_mother, &block)
+        steps_proc = lambda{|status| step_mother.steps(status)}
+        dump_count(step_mother.steps.length, "step") + dump_status_counts(steps_proc, &block)
+      end
+
+      private
+
+      def dump_status_counts(find_elements_proc)
+        counts = [:failed, :skipped, :undefined, :pending, :passed].map do |status|
+          elements = find_elements_proc.call(status)
+          elements.any? ? yield("#{elements.length} #{status.to_s}", status) : nil
+        end.compact
+        if counts.any?
+          " (#{counts.join(', ')})"
+        else
+          ""
+        end
+      end
+
+      def dump_count(count, what, state=nil)
+        [count, state, "#{what}#{count == 1 ? '' : 's'}"].compact.join(" ")
+      end
+
+    end
+  end
+end

data/lib/cucumber/formatter/unicode.rb

@@ -0,0 +1,79 @@
+# 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'
+$KCODE='u' unless Cucumber::RUBY_1_9
+
+if Cucumber::WINDOWS
+  require 'iconv' unless Cucumber::RUBY_1_9
+
+  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
+    module WindowsOutput #:nodoc:
+      def self.extended(o)
+        o.instance_eval do
+          alias cucumber_print print
+          def print(*a)
+            if Cucumber::RUBY_1_9
+              begin
+                cucumber_print(*a.map{|arg| arg.to_s.encode(Encoding.default_external)})
+              rescue Encoding::UndefinedConversionError => e
+                STDERR.cucumber_puts("WARNING: #{e.message}")
+                cucumber_print(*a)
+              end
+            else
+              begin
+                cucumber_print(*Iconv.iconv(Cucumber::CODEPAGE, "UTF-8", *a.map{|a|a.to_s}))
+              rescue Iconv::InvalidEncoding => e
+                STDERR.cucumber_puts("WARNING: #{e.message}")
+                cucumber_print(*a)
+              rescue Iconv::IllegalSequence => e
+                STDERR.cucumber_puts("WARNING: #{e.message}")
+                cucumber_print(*a)
+              end
+            end
+          end
+
+          alias cucumber_puts puts
+          def puts(*a)
+            if Cucumber::RUBY_1_9
+              begin
+                cucumber_puts(*a.map{|arg| arg.to_s.encode(Encoding.default_external)})
+              rescue Encoding::UndefinedConversionError => e
+                STDERR.cucumber_puts("WARNING: #{e.message}")
+                cucumber_puts(*a)
+              end
+            else
+              begin
+                cucumber_puts(*Iconv.iconv(Cucumber::CODEPAGE, "UTF-8", *a.map{|a|a.to_s}))
+              rescue Iconv::InvalidEncoding => e
+                STDERR.cucumber_print("WARNING: #{e.message}")
+                cucumber_print(*a)
+              rescue Iconv::IllegalSequence => e
+                STDERR.cucumber_puts("WARNING: #{e.message}")
+                cucumber_puts(*a)
+              end
+            end
+          end
+        end
+      end
+
+      Kernel.extend(self)
+      STDOUT.extend(self)
+      STDERR.extend(self)
+    end
+  end
+end

data/lib/cucumber/formatter/usage.rb

@@ -0,0 +1,127 @@
+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(step_mother, path_or_io, options)
+        @step_mother = step_mother
+        @io = ensure_io(path_or_io, "usage")
+        @options = options
+        @stepdef_to_match = Hash.new{|h,stepdef_key| h[stepdef_key] = []}
+      end
+
+      def before_step(step)
+        @step = step
+        @start_time = Time.now
+      end
+
+      def before_step_result(*args)
+        @duration = Time.now - @start_time
+      end
+
+      def after_step_result(keyword, step_match, multiline_arg, status, exception, source_indent, background)
+        if step_match.name.nil? # nil if it's from a scenario outline
+          stepdef_key = StepDefKey.new(step_match.step_definition.regexp_source, step_match.step_definition.file_colon_line)
+
+          @stepdef_to_match[stepdef_key] << {
+            :keyword => keyword, 
+            :step_match => step_match, 
+            :status => status, 
+            :file_colon_line => @step.file_colon_line,
+            :duration => @duration
+          }
+        end
+        super
+      end
+
+      def print_summary(features)
+        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.file_colon_line}".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[:file_colon_line]}".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 = Ast::StepInvocation.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 add_unused_stepdefs
+        @step_mother.unmatched_step_definitions.each do |step_definition|
+          stepdef_key = StepDefKey.new(step_definition.regexp_source, step_definition.file_colon_line)
+          @stepdef_to_match[stepdef_key] = []
+        end
+      end
+    end
+  end
+end

data/lib/cucumber/js_support/js_dsl.js

@@ -0,0 +1,57 @@
+var CucumberJsDsl = {
+  registerStepDefinition: function(regexp, func) {
+    if(func == null) {
+      jsLanguage.execute_step_definition(regexp);
+    }
+    else{
+      jsLanguage.add_step_definition(regexp, func);
+    }
+  },
+
+  registerTransform: function(regexp, func) {
+    jsLanguage.register_js_transform(regexp, func);
+  },
+
+  beforeHook: function(tag_expressions_or_func, func) {
+    CucumberJsDsl.__registerJsHook('before', tag_expressions_or_func, func);
+  },
+
+  afterHook: function(tag_expressions_or_func, func) {
+    CucumberJsDsl.__registerJsHook('after', tag_expressions_or_func, func);
+  },
+
+  steps: function(step_names) {
+    jsLanguage.steps(step_names, "UNKNOWN:0");
+  },
+
+  Table: function(raw_table) {
+    //TODO: Create a ruby table and send it back for use in js world
+  },
+
+  world: function(files) {
+    jsLanguage.world(files);
+  },
+
+  __registerJsHook: function(label, tag_expressions_or_func, func) {
+    if(func != null) {
+      var hook_func = func;
+      var tag_expressions = tag_expressions_or_func;
+    } else {
+      var hook_func = tag_expressions_or_func;
+      var tag_expressions = [];
+    }
+    jsLanguage.register_js_hook(label, tag_expressions, hook_func);
+  }
+}
+
+var Given = CucumberJsDsl.registerStepDefinition;
+var When = CucumberJsDsl.registerStepDefinition;
+var Then = CucumberJsDsl.registerStepDefinition;
+
+var Before = CucumberJsDsl.beforeHook;
+var After = CucumberJsDsl.afterHook;
+var Transform = CucumberJsDsl.registerTransform;
+
+var World = CucumberJsDsl.world;
+
+var steps = CucumberJsDsl.steps;

data/lib/cucumber/js_support/js_language.rb

@@ -0,0 +1,185 @@
+begin
+  require 'v8'
+rescue LoadError
+  gem 'therubyracer', '~> 0.7.1'
+  require 'v8'
+end
+
+require 'cucumber/js_support/js_snippets'
+
+module Cucumber
+  module JsSupport
+
+    def self.argument_safe_string(string)
+      arg_string = string.to_s.gsub(/[']/, '\\\\\'')
+      arg_string.gsub("\n", '\n')
+    end
+
+    class JsWorld
+      def initialize
+        @world = V8::Context.new
+      end
+
+      def execute(js_function, args=[])
+        js_function.call(*args)
+      end
+
+      def method_missing(method_name, *args)
+        @world.send(method_name, *args)
+      end
+    end
+
+    class JsStepDefinition
+      def initialize(js_language, regexp, js_function)
+        @js_language, @regexp, @js_function = js_language, regexp.to_s, js_function
+      end
+
+      def invoke(args)
+        args = @js_language.execute_transforms(args)
+        @js_language.current_world.execute(@js_function, args)
+      end
+
+      def regexp_source
+        @regexp.inspect
+      end
+
+      def arguments_from(step_name)
+        matches = eval_js "#{@regexp}.exec('#{step_name}')"
+        if matches
+          matches.to_a[1..-1].map do |match|
+            JsArg.new(match)
+          end
+        end
+      end
+
+      def file_colon_line
+        # Not possible yet to get file/line of js function with V8/therubyracer
+        ""
+      end
+    end
+
+    class JsHook
+      def initialize(js_language, tag_expressions, js_function)
+        @js_language, @tag_expressions, @js_function = js_language, tag_expressions, js_function
+      end
+
+      def tag_expressions
+        @tag_expressions
+      end
+
+      def invoke(location, scenario)
+        @js_language.current_world.execute(@js_function)
+      end
+    end
+
+    class JsTransform
+      def initialize(js_language, regexp, js_function)
+        @js_language, @regexp, @js_function = js_language, regexp.to_s, js_function
+      end
+
+      def match(arg)
+        arg = JsSupport.argument_safe_string(arg)
+        matches = (eval_js "#{@regexp}.exec('#{arg}');").to_a
+        matches.empty? ? nil : matches[1..-1]
+      end
+
+      def invoke(arg)
+        @js_function.call([arg])
+      end
+    end
+
+    class JsArg
+      def initialize(arg)
+        @arg = arg
+      end
+
+      def val
+        @arg
+      end
+
+      def byte_offset
+      end
+    end
+
+    class JsLanguage
+      include LanguageSupport::LanguageMethods
+      include JsSnippets
+
+      def initialize(runtime)
+        @step_definitions = []
+        @world = JsWorld.new
+        @runtime = runtime
+
+        @world["jsLanguage"] = self
+        @world.load(File.dirname(__FILE__) + '/js_dsl.js')
+      end
+
+      def load_code_file(js_file)
+        @world.load(js_file)
+      end
+
+      def world(js_files)
+        js_files.each do |js_file|
+          load_code_file("#{path_to_load_js_from}#{js_file}")
+        end
+      end
+
+      def alias_adverbs(adverbs)
+      end
+
+      def begin_scenario(scenario)
+        @language = scenario.language
+      end
+
+      def end_scenario
+      end
+
+      def step_matches(name_to_match, name_to_format)
+        @step_definitions.map do |step_definition|
+          if(arguments = step_definition.arguments_from(name_to_match))
+            StepMatch.new(step_definition, name_to_match, name_to_format, arguments)
+          else
+            nil
+          end
+        end.compact
+      end
+
+      def add_step_definition(regexp, js_function)
+        @step_definitions << JsStepDefinition.new(self, regexp, js_function)
+      end
+
+      #TODO: support multiline arguments when calling steps from within steps
+      def execute_step_definition(name, multiline_argument = nil)
+        @runtime.step_match(name).invoke(multiline_argument)
+      end
+
+      def register_js_hook(phase, tag_expressions, js_function)
+        add_hook(phase, JsHook.new(self, tag_expressions, js_function))
+      end
+
+      def register_js_transform(regexp, js_function)
+        add_transform(JsTransform.new(self, regexp, js_function))
+      end
+
+      def current_world
+        @world
+      end
+
+      def steps(steps_text, file_colon_line)
+        @runtime.invoke_steps(steps_text, @language, file_colon_line)
+      end
+
+      private
+      def path_to_load_js_from
+        paths = @runtime.features_paths
+        if paths.empty?
+          '' # Using rake
+        else
+          path = paths[0][/(^.*\/?features)/, 0]
+          path ? "#{path}/../" : '../'
+        end
+      end
+
+    end
+  end
+end