aslakhellesoy-cucumber 0.1.5 → 0.1.9

data/gem_tasks/treetop.rake

@@ -0,0 +1,41 @@
+class FeatureCompiler
+  def initialize
+    require 'yaml'
+    require 'erb'
+    
+    @tt = PLATFORM =~ /mswin|mingw/ ? 'tt.bat' : 'tt'
+
+    @template = ERB.new(IO.read(File.dirname(__FILE__) + '/../lib/cucumber/treetop_parser/feature.treetop.erb'))
+    @langs = YAML.load_file(File.dirname(__FILE__) + '/../lib/cucumber/languages.yml')
+  end
+  
+  def compile_all
+    @langs.keys.each do |lang|
+      compile(lang)
+    end
+  end
+  
+  def compile(lang)
+    words = @langs['en'].merge(@langs[lang]) # Use English words if languages.yml is missing a word
+    grammar_file = File.dirname(__FILE__) + "/../lib/cucumber/treetop_parser/feature_#{lang}.treetop"
+    ruby_file    = File.dirname(__FILE__) + "/../lib/cucumber/treetop_parser/feature_#{lang}.rb"
+    grammar      = @template.result(binding)
+    File.open(grammar_file, "wb") do |io|
+      io.write(grammar)
+    end
+    sh "#{@tt} #{grammar_file}"
+    FileUtils.rm(grammar_file)
+  end
+end
+
+namespace :treetop do
+  desc 'Compile the grammar for all languages in languages.yml'
+  task :compile do
+    FeatureCompiler.new.compile_all
+  end
+
+  desc 'Compile the English grammar'
+  task :compile_en do
+    FeatureCompiler.new.compile('en')
+  end
+end

data/lib/autotest/cucumber.rb

@@ -0,0 +1,6 @@
+require 'autotest'
+require 'autotest/cucumber_mixin'
+
+class Autotest::Cucumber < Autotest
+  include CucumberMixin
+end

data/lib/autotest/cucumber_mixin.rb

@@ -0,0 +1,109 @@
+require 'autotest'
+require 'tempfile'
+
+module Autotest::CucumberMixin
+  def self.included(receiver)
+    receiver::ALL_HOOKS << [:run_features, :ran_features]
+  end
+  
+  attr_accessor :scenarios_to_run
+  
+  def initialize
+    super
+    reset_features
+  end
+  
+  def run
+    hook :initialize
+    reset
+    reset_features
+    add_sigint_handler
+
+    self.last_mtime = Time.now if $f
+
+    loop do # ^c handler
+      begin
+        get_to_green
+        if self.tainted then
+          rerun_all_tests
+          rerun_all_features if all_good
+        else
+          hook :all_good
+        end
+        wait_for_changes
+        # Once tests and features are green, reset features every
+        # time a file is changed to see if anything breaks.
+        reset_features
+      rescue Interrupt
+        break if self.wants_to_quit
+        reset
+        reset_features
+      end
+    end
+    hook :quit
+  end
+  
+  def all_features_good
+    scenarios_to_run == []
+  end
+  
+  def get_to_green
+    begin
+      super
+      run_features
+      wait_for_changes unless all_features_good
+    end until all_features_good
+  end
+  
+  def rerun_all_features
+    reset_features
+    run_features
+  end
+  
+  def reset_features
+    self.scenarios_to_run = :all
+  end
+    
+  def run_features
+    hook :run_features
+    Tempfile.open('autotest-cucumber') do |dirty_scenarios_file|
+      cmd = self.make_cucumber_cmd self.scenarios_to_run, dirty_scenarios_file.path
+      return if cmd.empty?
+      puts cmd unless $q
+      system cmd
+      self.scenarios_to_run = dirty_scenarios_file.readlines.map { |l| l.chomp }
+      self.tainted = true unless self.scenarios_to_run == []
+    end
+    hook :ran_features
+  end
+  
+  def make_cucumber_cmd(scenarios_to_run, dirty_scenarios_filename)
+    return '' if scenarios_to_run == []
+    
+    profiles = YAML.load_file("cucumber.yml").keys rescue []
+    
+    profile ||= "autotest-all" if profiles.include?("autotest-all") and scenarios_to_run == :all
+    profile ||= "autotest"     if profiles.include?("autotest")
+    profile ||= nil
+    
+    if profile
+      args = ["--profile", profile]
+    else
+      args = %w{features --format} << (scenarios_to_run == :all ? "progress" : "pretty")
+    end
+    args += %w{--format autotest --out} << dirty_scenarios_filename
+    args = args.join(' ')
+    
+    if scenarios_to_run == :all
+      scenario_args = nil
+    else
+      scenario_args = scenarios_to_run.map { |s| "-s '#{s}'" }.join(' ')
+    end
+    
+    return "#{cucumber} #{args} #{scenario_args}"
+  end
+  
+  def cucumber
+    File.exist?("script/cucumber") ? "script/cucumber" : "cucumber"
+  end
+end

data/lib/autotest/cucumber_rails.rb

@@ -0,0 +1,6 @@
+require 'autotest/rails'
+require 'autotest/cucumber_mixin'
+
+class Autotest::CucumberRails < Autotest::Rails
+  include CucumberMixin
+end

data/lib/autotest/cucumber_rails_rspec.rb

@@ -0,0 +1,6 @@
+require 'autotest/cucumber_mixin'
+require 'autotest/rails_rspec'
+
+class Autotest::CucumberRailsRspec < Autotest::RailsRspec
+  include CucumberMixin
+end

data/lib/autotest/cucumber_rspec.rb

@@ -0,0 +1,6 @@
+require 'autotest/cucumber_mixin'
+require 'autotest/rspec'
+
+class Autotest::CucumberRspec < Autotest::Rspec
+  include CucumberMixin
+end

data/lib/autotest/discover.rb

@@ -0,0 +1,9 @@
+Autotest.add_discovery do
+  if File.directory?('features')
+    if ENV['AUTOFEATURE'] == 'true'
+      "cucumber"
+    else
+      puts "(Not running features.  To run features in autotest, set AUTOFEATURE=true.)"
+    end
+  end
+end

data/lib/cucumber.rb

@@ -0,0 +1,39 @@
+$:.unshift(File.dirname(__FILE__)) unless
+  $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
+require 'rubygems'
+require 'treetop/runtime'
+require 'treetop/ruby_extensions'
+require 'cucumber/version'
+require 'cucumber/step_methods'
+require 'cucumber/tree'
+require 'cucumber/model'
+require 'cucumber/executor'
+require 'cucumber/step_mother'
+require 'cucumber/formatters'
+require 'cucumber/treetop_parser/feature_parser'
+require 'cucumber/cli'
+require 'cucumber/broadcaster'
+
+$KCODE='u'
+require 'jcode'
+
+module Cucumber
+  LANGUAGE_FILE = File.expand_path(File.dirname(__FILE__) + '/cucumber/languages.yml')
+
+  class << self
+    attr_reader :language
+    
+    def load_language(lang)
+      @language = config[lang]
+    end
+    
+    def languages
+      config.keys.sort
+    end
+    
+    def config
+      require 'yaml'
+      @config ||= YAML.load_file(LANGUAGE_FILE)
+    end
+  end  
+end

data/lib/cucumber/broadcaster.rb

@@ -0,0 +1,20 @@
+module Cucumber
+  class Broadcaster
+
+    def initialize(receivers = [])
+      @receivers = receivers
+    end
+
+    def register(receiver)
+      @receivers << receiver
+    end
+
+    def method_missing(method_name, *args)
+      @receivers.each  do |receiver|
+        r = (receiver == STDOUT) ? Kernel: receiver # Needed to make colors work on Windows
+        r.__send__(method_name, *args) if receiver.respond_to?(method_name)
+      end
+    end
+
+  end
+end

data/lib/cucumber/cli.rb

@@ -0,0 +1,269 @@
+require 'optparse'
+require 'cucumber'
+
+module Cucumber
+  class CLI
+    class << self
+      attr_writer :step_mother, :executor, :features
+
+      def execute
+        @execute_called = true
+        parse(ARGV).execute!(@step_mother, @executor, @features)
+      end
+
+      def execute_called?
+        @execute_called
+      end
+
+      def parse(args)
+        cli = new
+        cli.parse_options!(args)
+        cli
+      end
+    end
+
+    attr_reader :options
+    FORMATS = %w{pretty profile progress html autotest}
+    DEFAULT_FORMAT = 'pretty'
+
+    def initialize(out_stream = STDOUT, error_stream = STDERR)
+      @out_stream = out_stream
+      @error_stream = error_stream
+      @paths = []
+      @options = {
+        :require => nil,
+        :lang    => 'en',
+        :dry_run => false,
+        :source  => true,
+        :snippets => true,
+        :formats => {},
+        :excludes => [],
+        :scenario_names => nil
+      }
+      @active_format = DEFAULT_FORMAT
+    end
+
+    def parse_options!(args)
+      return parse_args_from_profile('default') if args.empty?
+      args.extend(OptionParser::Arguable)
+
+      args.options do |opts|
+        opts.banner = "Usage: cucumber [options] FILES|DIRS"
+        opts.on("-r LIBRARY|DIR", "--require LIBRARY|DIR", "Require files before executing the features.",
+          "If this option is not specified, all *.rb files that",
+          "are siblings or below the features will be autorequired",
+          "This option can be specified multiple times.") do |v|
+          @options[:require] ||= []
+          @options[:require] << v
+        end
+        opts.on("-l LINE", "--line LINE", "Only execute the scenario at the given line") do |v|
+          @options[:line] = v
+        end
+        opts.on("-s SCENARIO", "--scenario SCENARIO", "Only execute the scenario with the given name.",
+                                                      "If this option is given more than once, run all",
+                                                      "the specified scenarios.") do |v|
+          @options[:scenario_names] ||= []
+          @options[:scenario_names] << v
+        end
+        opts.on("-a LANG", "--language LANG", "Specify language for features (Default: #{@options[:lang]})",
+          "Available languages: #{Cucumber.languages.join(", ")}",
+          "Look at #{Cucumber::LANGUAGE_FILE} for keywords") do |v|
+          @options[:lang] = v
+        end
+        opts.on("-f FORMAT", "--format FORMAT", "How to format features (Default: #{DEFAULT_FORMAT})",
+          "Available formats: #{FORMATS.join(", ")}",
+          "This option can be specified multiple times.") do |v|
+          unless FORMATS.index(v)
+            @error_stream.puts "Invalid format: #{v}\n"
+            @error_stream.puts opts.help
+            exit 1
+          end
+          @options[:formats][v] ||= []
+          @options[:formats][v] << @out_stream
+          @active_format = v
+        end
+        opts.on("-o", "--out FILE", "Write output to a file instead of @out_stream.",
+          "This option can be specified multiple times, and applies to the previously",
+          "specified --format.") do |v|
+          @options[:formats][@active_format] ||= []
+          if @options[:formats][@active_format].last == @out_stream
+            @options[:formats][@active_format][-1] = File.open(v, 'w')
+          else
+            @options[:formats][@active_format] << File.open(v, 'w')
+          end
+        end
+        opts.on("-c", "--[no-]color", "Use ANSI color in the output, if formatters use it.  If",
+                                      "these options are given multiple times, the last one is",
+                                      "used.  If neither --color or --no-color is given cucumber",
+                                      "decides based on your platform and the output destination") do |v|
+          @options[:color] = v
+        end
+        opts.on("-e", "--exclude PATTERN", "Don't run features matching a pattern") do |v|
+          @options[:excludes] << v
+        end
+        opts.on("-p", "--profile PROFILE", "Pull commandline arguments from cucumber.yml.") do |v|
+          parse_args_from_profile(v)
+        end
+        opts.on("-d", "--dry-run", "Invokes formatters without executing the steps.") do
+          @options[:dry_run] = true
+        end
+        opts.on("-n", "--no-source", "Don't show the file and line of the step definition with the steps.") do
+          @options[:source] = false
+        end
+        opts.on("-i", "--no-snippets", "Don't show the snippets for pending steps") do
+          @options[:snippets] = false
+        end
+        opts.on("-q", "--quiet", "Don't show any development aid information") do
+          @options[:snippets] = false
+          @options[:source] = false
+        end
+        opts.on_tail("--version", "Show version") do
+          puts VERSION::STRING
+          exit
+        end
+        opts.on_tail("--help", "You're looking at it") do
+          puts opts.help
+          exit
+        end
+      end.parse!
+
+      if @options[:formats].empty?
+        @options[:formats][DEFAULT_FORMAT] = [@out_stream]
+      end
+
+      # Whatever is left after option parsing is the FILE arguments
+      @paths += args
+    end
+
+    def parse_args_from_profile(profile)
+      unless File.exist?('cucumber.yml')
+        return exit_with_error("cucumber.yml was not found.  Please define your '#{profile}' and other profiles in cucumber.yml.\n"+
+                               "Type 'cucumber --help' for usage.\n")
+      end
+      
+      require 'yaml'
+      cucumber_yml = YAML::load(IO.read('cucumber.yml'))
+      args_from_yml = cucumber_yml[profile]
+      if args_from_yml.nil?
+        exit_with_error <<-END_OF_ERROR
+Could not find profile: '#{profile}'
+
+Defined profiles in cucumber.yml:
+  * #{cucumber_yml.keys.join("\n  * ")}
+        END_OF_ERROR
+      elsif !args_from_yml.is_a?(String)
+        exit_with_error "Profiles must be defined as a String.  The '#{profile}' profile was #{args_from_yml.inspect} (#{args_from_yml.class}).\n"
+      else
+        parse_options!(args_from_yml.split(' '))
+      end
+    end
+
+    def execute!(step_mother, executor, features)
+      Term::ANSIColor.coloring = @options[:color] unless @options[:color].nil?
+      Cucumber.load_language(@options[:lang])
+      executor.formatters = build_formatter_broadcaster(step_mother)
+      require_files
+      load_plain_text_features(features)
+      executor.line = @options[:line].to_i if @options[:line]
+      executor.scenario_names = @options[:scenario_names] if @options[:scenario_names]
+      executor.visit_features(features)
+      exit 1 if executor.failed
+    end
+
+    private
+
+    # Requires files - typically step files and ruby feature files.
+    def require_files
+      ARGV.clear # Shut up RSpec
+      require "cucumber/treetop_parser/feature_#{@options[:lang]}"
+      require "cucumber/treetop_parser/feature_parser"
+
+      requires = @options[:require] || feature_dirs
+      libs = requires.map do |path|
+        path = path.gsub(/\\/, '/') # In case we're on windows. Globs don't work with backslashes.
+        File.directory?(path) ? Dir["#{path}/**/*.rb"] : path
+      end.flatten.uniq
+      libs.each do |lib|
+        begin
+          require lib
+        rescue LoadError => e
+          e.message << "\nFailed to load #{lib}"
+          raise e
+        end
+      end
+    end
+
+    def feature_files
+      potential_feature_files = @paths.map do |path|
+        path = path.gsub(/\\/, '/') # In case we're on windows. Globs don't work with backslashes.
+        path = path.chomp('/')
+        File.directory?(path) ? Dir["#{path}/**/*.feature"] : path
+      end.flatten.uniq
+
+      @options[:excludes].each do |exclude|
+        potential_feature_files.reject! do |path|
+          path =~ /#{Regexp.escape(exclude)}/
+        end
+      end
+
+      potential_feature_files
+    end
+
+    def feature_dirs
+      feature_files.map{|f| File.directory?(f) ? f : File.dirname(f)}.uniq
+    end
+
+    def load_plain_text_features(features)
+      parser = TreetopParser::FeatureParser.new
+
+      feature_files.each do |f|
+        features << parser.parse_feature(f)
+      end
+    end
+
+    def build_formatter_broadcaster(step_mother)
+      formatter_broadcaster = Broadcaster.new
+      @options[:formats].each do |format, output_list|
+        output_broadcaster = build_output_broadcaster(output_list)
+        case format
+        when 'pretty'
+          formatter_broadcaster.register(Formatters::PrettyFormatter.new(output_broadcaster, step_mother, @options))
+        when 'progress'
+          formatter_broadcaster.register(Formatters::ProgressFormatter.new(output_broadcaster))
+        when 'profile'
+          formatter_broadcaster.register(Formatters::ProfileFormatter.new(output_broadcaster, step_mother))
+        when 'html'
+          formatter_broadcaster.register(Formatters::HtmlFormatter.new(output_broadcaster, step_mother))
+        when 'autotest'
+          formatter_broadcaster.register(Formatters::AutotestFormatter.new(output_broadcaster))
+        else
+          raise "Unknown formatter: #{@options[:format]}"
+        end
+      end
+      formatter_broadcaster
+    end
+
+    def build_output_broadcaster(output_list)
+      output_broadcaster = Broadcaster.new
+      output_list.each do |output|
+        output_broadcaster.register(output)
+      end
+      output_broadcaster
+    end
+    
+  private
+
+    def exit_with_error(error_message)
+      @error_stream << error_message
+      Kernel.exit 1
+    end
+
+  end
+end
+
+extend Cucumber::StepMethods
+Cucumber::CLI.step_mother = step_mother
+Cucumber::CLI.executor = executor
+
+extend Cucumber::Tree
+Cucumber::CLI.features = features