cucumber 0.1.10 → 0.2.0

data/examples/selenium/features/step_definitons/stories_steps.rb

@@ -1,41 +0,0 @@
-require 'spec'
-require 'selenium'
-
-class GoogleSearch
-  def initialize(browser)
-    @browser = browser
-  end
-  
-  def goto
-    @browser.open 'http://www.google.com/'
-  end
-  
-  def search(text)
-    @browser.type('q',text)   
-    @browser.click 'btnG'
-    @browser.wait_for_page_to_load
-  end
-end
-
-Before do
-  @browser = Selenium::SeleniumDriver.new("localhost", 4444, "*chrome", "http://localhost", 15000)
-  @browser.start
-end
-
-After do
-  @browser.stop
-end
-
-Given 'I am on the Google search page' do
-  @page = GoogleSearch.new(@browser)
-  @page.goto
-end
-
-When /I search for "(.*)"/ do |query|
-  @page.search(query)
-end
-
-Then /I should see a link to "(.*)":(.*)/ do |text, expected_url|
-  observed_url = @browser.get_attribute("link=#{text}@href")
-  observed_url.should == expected_url
-end

data/examples/watir/features/step_definitons/stories_steps.rb

@@ -1,51 +0,0 @@
-require 'spec'
-
-case PLATFORM
-when /darwin/
-  require 'safariwatir'
-  Browser = Watir::Safari
-when /win32|mingw/
-  require 'watir'
-  Browser = Watir::IE
-when /java/
-  require 'celerity'
-  Browser = Celerity::Browser
-else
-  raise "This platform is not supported (#{PLATFORM})"
-end
-
-Before do
-  @b = Browser.new
-end
-
-After do
-  @b.close
-end
-
-class GoogleSearch
-  def initialize(b)
-    @b = b
-  end
-  
-  def goto
-    @b.goto 'http://www.google.com/'
-  end
-  
-  def search(text)
-    @b.text_field(:name, 'q').set(text)
-    @b.button(:name, 'btnG').click
-  end
-end
-
-Given 'I am on the Google search page' do
-  @page = GoogleSearch.new(@b)
-  @page.goto
-end
-
-When /I search for "(.*)"/ do |query|
-  @page.search(query)
-end
-
-Then /I should see a link to "(.*)":(.*)/ do |text, url|
-  @b.link(:url, url).text.should == text
-end

data/features/see_features.feature

@@ -1,8 +0,0 @@
-Feature: See features
-  In order to make Cucumber features more accessible
-  I should be able to see the existing features in a system
-  
-  Scenario: See features as HTML
-    Given the feature server is running
-    When I visit "/features"
-    Then I should see a link to "See features"

data/features/steps/features_steps.rb

@@ -1,9 +0,0 @@
-Given /the feature server is running/ do
-  raise "TODO"
-end
-
-When /I visit "(.*)"/ do |resource|
-end
-
-Then /I should see a link to "(.*)"/ do |text|
-end

data/gem_tasks/treetop.rake

@@ -1,41 +0,0 @@
-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/cucumber/cli.rb

@@ -1,279 +0,0 @@
-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, :paths
-    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("-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
-      args = extract_and_store_line_numbers(args)
-      @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.lines_for_features = @options[:lines_for_features]
-      executor.scenario_names = @options[:scenario_names] if @options[:scenario_names]
-      executor.visit_features(features)
-      exit 1 if executor.failed
-    end
-
-    private
-
-    def extract_and_store_line_numbers(file_arguments)
-      @options[:lines_for_features] = Hash.new{|k,v| k[v] = []}
-      file_arguments.map do |arg|
-        _, file, lines = */^([\w\W]*?):([\d:]+)$/.match(arg)
-        unless file.nil?
-          @options[:lines_for_features][file] += lines.split(':').map { |line| line.to_i }
-          arg = file          
-        end
-        arg
-      end
-    end
-    
-    # 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

data/lib/cucumber/executor.rb

@@ -1,190 +0,0 @@
-require 'cucumber/core_ext/proc'
-
-module Cucumber
-  class Executor
-    attr_reader :failed
-    attr_accessor :formatters
-    attr_writer :scenario_names, :lines_for_features
-
-    def initialize(step_mother)
-      @world_procs = []
-      @before_scenario_procs = []
-      @after_scenario_procs = []
-      @after_step_procs = []
-      @step_mother = step_mother
-
-      @executed_scenarios = {}
-      @regular_scenario_cache = {}
-    end
-
-    def register_world_proc(&proc)
-      @world_procs << proc
-    end
-
-    def register_before_scenario_proc(&proc)
-      proc.extend(CoreExt::CallIn)
-      @before_scenario_procs << proc
-    end
-
-    def register_after_scenario_proc(&proc)
-      proc.extend(CoreExt::CallIn)
-      @after_scenario_procs << proc
-    end
-
-    def register_after_step_proc(&proc)
-      proc.extend(CoreExt::CallIn)
-      @after_step_procs << proc
-    end
-
-    def visit_features(features)
-      formatters.visit_features(features)
-      features.accept(self)
-      formatters.dump
-    end
-
-    def visit_feature(feature)
-      @feature_file = feature.file
-            
-      if accept_feature?(feature)
-        formatters.feature_executing(feature)
-        feature.accept(self)
-        @executed_scenarios = {}
-        @regular_scenario_cache = {}
-      end
-    end
-
-    def visit_header(header)
-      formatters.header_executing(header)
-    end
-
-    def visit_row_scenario(scenario)
-      execute_scenario(@regular_scenario_cache[scenario.name]) if executing_unprepared_row_scenario?(scenario)
-      visit_scenario(scenario)
-    end
-
-    def visit_regular_scenario(scenario)
-      @regular_scenario_cache[scenario.name] = scenario
-      visit_scenario(scenario)
-    end
-
-    def visit_scenario(scenario)
-      if accept_scenario?(scenario)
-        @executed_scenarios[scenario.name] = true
-        execute_scenario(scenario)
-      end
-    end
-
-    def execute_scenario(scenario)
-      @error = nil
-      @pending = nil
-
-      @world = create_world
-      @world.extend(Spec::Matchers) if defined?(Spec::Matchers)
-      define_step_call_methods(@world)
-
-      formatters.scenario_executing(scenario)
-      @before_scenario_procs.each{|p| p.call_in(@world, *[])}
-      scenario.accept(self)
-      @after_scenario_procs.each{|p| p.call_in(@world, *[])}
-      formatters.scenario_executed(scenario)
-    end
-    
-    def accept_scenario?(scenario)
-      scenario_at_specified_line?(scenario) &&
-      scenario_has_specified_name?(scenario)
-    end
-
-    def accept_feature?(feature)
-      feature.scenarios.any? { |s| accept_scenario?(s) }
-    end
-
-    def visit_row_step(step)
-      visit_step(step)
-    end
-
-    def visit_regular_step(step)
-      visit_step(step)
-    end
-
-    def visit_step(step)
-      unless @pending || @error
-        begin
-          regexp, args, proc = step.regexp_args_proc(@step_mother)
-          formatters.step_executing(step, regexp, args)
-          step.execute_in(@world, regexp, args, proc)
-          @after_step_procs.each{|p| p.call_in(@world, *[])}
-          formatters.step_passed(step, regexp, args)
-        rescue Pending
-          record_pending_step(step, regexp, args)
-        rescue => e
-          @failed = true
-          @error = step.error = e
-          formatters.step_failed(step, regexp, args)
-        end
-      else
-        begin
-          regexp, args, proc = step.regexp_args_proc(@step_mother)
-          step.execute_in(@world, regexp, args, proc)
-          formatters.step_skipped(step, regexp, args)
-        rescue Pending
-          record_pending_step(step, regexp, args)
-        rescue Exception
-          formatters.step_skipped(step, regexp, args)
-        end
-      end
-    end
-
-    def record_pending_step(step, regexp, args)
-      @pending = true
-      formatters.step_pending(step, regexp, args)
-    end
-
-    def define_step_call_methods(world)
-      world.instance_variable_set('@__executor', self)
-      world.instance_eval do
-        class << self
-          def run_step(name)
-            _, args, proc = @__executor.instance_variable_get(:@step_mother).regexp_args_proc(name)
-            proc.call_in(self, *args)
-          end
-
-          %w{given when then and but}.each do |keyword|
-            alias_method Cucumber.language[keyword], :run_step
-          end
-        end
-      end
-    end
-    
-    def executing_unprepared_row_scenario?(scenario)
-      accept_scenario?(scenario) && !@executed_scenarios[scenario.name]
-    end
-    
-    def scenario_at_specified_line?(scenario)
-      if lines_defined_for_current_feature?
-        @lines_for_features[@feature_file].inject(false) { |at_line, line| at_line || scenario.at_line?(line) }
-      else
-        true
-      end
-    end
-    
-    def scenario_has_specified_name?(scenario)
-      if @scenario_names && !@scenario_names.empty?
-        @scenario_names.include?(scenario.name)
-      else
-        true
-      end
-    end
-    
-    def lines_defined_for_current_feature?
-      @lines_for_features && !@lines_for_features[@feature_file].nil? && !@lines_for_features[@feature_file].empty?
-    end
-    
-    def create_world
-      world = Object.new
-      @world_procs.each do |world_proc|
-        world = world_proc.call(world)
-      end
-      world
-    end
-  end
-end