kosmas58-cucumber 0.1.99.22 → 0.1.99.23

data/lib/cucumber/step_mother.rb

@@ -0,0 +1,194 @@
+require 'cucumber/step_definition'
+require 'cucumber/core_ext/instance_exec'
+
+module Cucumber
+  class Undefined < StandardError
+    attr_reader :step_name
+
+    def initialize(step_name)
+      super %{Undefined step: "#{step_name}"}
+      @step_name = step_name
+    end
+    Cucumber::EXCEPTION_STATUS[self] = :undefined
+  end
+
+  class Pending < StandardError
+    Cucumber::EXCEPTION_STATUS[self] = :pending
+  end
+
+  # Raised when a step matches 2 or more StepDefinition
+  class Ambiguous < StandardError
+    def initialize(step_name, step_definitions)
+      message = "Ambiguous match of \"#{step_name}\":\n\n"
+      message << step_definitions.map{|sd| sd.to_backtrace_line}.join("\n")
+      message << "\n\n"
+      super(message)
+    end
+  end
+
+  # Raised when 2 or more StepDefinition have the same Regexp
+  class Redundant < StandardError
+    def initialize(step_def_1, step_def_2)
+      message = "Multiple step definitions have the same Regexp:\n\n"
+      message << step_def_1.to_backtrace_line << "\n"
+      message << step_def_2.to_backtrace_line << "\n\n"
+      super(message)
+    end
+  end
+
+  # This is the main interface for registering step definitions, which is done
+  # from <tt>*_steps.rb</tt> files. This module is included right at the top-level
+  # so #register_step_definition (and more interestingly - its aliases) are
+  # available from the top-level.
+  module StepMother
+    attr_writer :snippet_generator
+    attr_writer :options
+    
+    # Registers a new StepDefinition. This method is aliased
+    # to <tt>Given</tt>, <tt>When</tt> and <tt>Then</tt>.
+    #
+    # See Cucumber#alias_steps for details on how to
+    # create your own aliases.
+    #
+    # The +&proc+ gets executed in the context of a <tt>world</tt>
+    # object, which is defined by #World. A new <tt>world</tt>
+    # object is created for each scenario and is shared across
+    # step definitions within that scenario.
+    def register_step_definition(regexp, &proc)
+      step_definition = StepDefinition.new(regexp, &proc)
+      step_definitions.each do |already|
+        raise Redundant.new(already, step_definition) if already.match(regexp)
+      end
+      step_definitions << step_definition
+      step_definition
+    end
+
+    def world(scenario, prior_world = nil, &proc)
+      world = prior_world || new_world
+      begin
+        (@before_procs ||= []).each do |proc|
+          world.cucumber_instance_exec(false, 'Before', scenario, &proc)
+        end
+        yield world
+      ensure
+        (@after_procs ||= []).each do |proc|
+          world.cucumber_instance_exec(false, 'After', scenario, &proc)
+        end
+      end
+    end
+
+    # Registers a Before proc. You can call this method as many times as you
+    # want (typically from ruby scripts under <tt>support</tt>).
+    def Before(&proc)
+      (@before_procs ||= []) << proc
+    end
+
+    def After(&proc)
+      (@after_procs ||= []) << proc
+    end
+
+    # Registers a World proc. You can call this method as many times as you
+    # want (typically from ruby scripts under <tt>support</tt>).
+    def World(&proc)
+      (@world_procs ||= []) << proc
+    end
+
+    # Creates a new world instance
+    def new_world #:nodoc:
+      world = Object.new
+      (@world_procs ||= []).each do |proc|
+        world = proc.call(world)
+      end
+
+      world.extend(WorldMethods)
+      world.__cucumber_step_mother = self
+
+      world.extend(::Spec::Matchers) if defined?(::Spec::Matchers)
+      world
+    end
+
+    # Looks up the StepDefinition that matches +step_name+
+    def step_definition(step_name) #:nodoc:
+      found = step_definitions.select do |step_definition|
+        step_definition.match(step_name)
+      end
+      raise Undefined.new(step_name) if found.empty?
+      found = best_matches(step_name, found) if found.size > 1 && options[:guess]
+      raise Ambiguous.new(step_name, found) if found.size > 1
+      found[0]
+    end
+
+    def best_matches(step_name, step_definitions)
+      top_group_score = step_definitions.map {|s| s.match(step_name).captures.length }.sort.last
+      top_groups = step_definitions.select {|s| s.match(step_name).captures.length == top_group_score }
+      if top_groups.size > 1
+        shortest_capture_length = top_groups.map {|s| s.match(step_name).captures.inject(0) {|sum, c| sum + c.length } }.sort.first
+        top_groups.select {|s| s.match(step_name).captures.inject(0) {|sum, c| sum + c.length } == shortest_capture_length }
+      else
+        top_groups
+      end
+    end
+    
+    def step_definitions
+      @step_definitions ||= []
+    end
+
+    def snippet_text(step_keyword, step_name)
+      @snippet_generator.snippet_text(step_keyword, step_name)
+    end
+    
+    def print_step_definitions(out)
+      step_definitions.each do |step_definition|
+        indent = max_step_definition_length - step_definition.text_length
+        out.puts(step_definition.to_s(indent))
+      end
+    end
+
+    private
+
+    def max_step_definition_length
+      @max_step_definition_length ||= step_definitions.map{|step_definition| step_definition.text_length}.max
+    end
+
+    def options
+      @options || {}
+    end
+
+    module WorldMethods #:nodoc:
+      attr_writer :__cucumber_step_mother, :__cucumber_current_step
+
+      # Call a step from within a step definition
+      def __cucumber_invoke(name, *multiline_arguments)
+        begin
+          # TODO: Very similar to code in Step. Refactor. Get back StepInvocation?
+          # Make more similar to JBehave?
+          step_definition = @__cucumber_step_mother.step_definition(name)
+          matched_args = step_definition.matched_args(name)
+          args = (matched_args + multiline_arguments)
+          step_definition.execute(name, self, *args)
+        rescue Exception => e
+          @__cucumber_current_step.exception = e
+          raise e
+        end
+      end
+      
+      def table(text, file=nil, line=0)
+        @table_parser ||= Parser::TableParser.new
+        @table_parser.parse_or_fail(text.strip, file, line)
+      end
+
+      def pending(message = "TODO")
+        if block_given?
+          begin
+            yield
+          rescue Exception => e
+            raise Pending.new(message)
+          end
+          raise Pending.new("Expected pending '#{message}' to fail. No Error was raised. No longer pending?")
+        else
+          raise Pending.new(message)
+        end
+      end
+    end
+  end
+end

data/lib/cucumber/version.rb

@@ -0,0 +1,10 @@
+module Cucumber #:nodoc:
+  class VERSION #:nodoc:
+    MAJOR = 0
+    MINOR = 1
+    TINY  = 99
+    PATCH = 23 # Set to nil for official release
+
+    STRING = [MAJOR, MINOR, TINY, PATCH].compact.join('.')
+  end
+end

data/rails_generators/cucumber/USAGE

@@ -0,0 +1,14 @@
+Description:
+    Sets up Cucumber in your Rails project. After running this generator you will
+    get a new rake task called features.
+    
+    This also generates the necessary files in the features directory.
+    
+    Also see the feature generator, which you can use to generate skeletons
+    for new features.
+    
+    If you set the language option, then a subdirectory features/[language] will be generated instead. 
+    Now your are able to use features in different languages.
+    
+Examples:
+    `./script/generate cucumber`

data/rails_generators/cucumber/cucumber_generator.rb

@@ -0,0 +1,75 @@
+require "rbconfig"
+ 
+# This generator bootstraps a Rails project for use with Cucumber
+class CucumberGenerator < Rails::Generator::Base  
+  DEFAULT_SHEBANG = File.join(Config::CONFIG["bindir"],
+                              Config::CONFIG["ruby_install_name"])
+  
+  attr_reader :language
+  attr_accessor :framework
+  
+  def initialize(runtime_args, runtime_options = {})
+    super
+    @features_path = "features"
+  end  
+  
+  def manifest 
+    if options[:language]
+      @language = options[:language]
+      set_language(@language)
+    end
+    record do |m|
+      m.directory  File.join(@features_path, "step_definitions")
+      if @language
+        m.file File.join(@language, "webrat_steps.rb"), File.join(@features_path, "step_definitions", "paths.rb")
+        m.file File.join(@language, "webrat_steps.rb"), File.join(@features_path, "step_definitions", "webrat_steps.rb")       
+      else
+        m.file "webrat_steps.rb", File.join(@features_path, "step_definitions", "webrat_steps.rb")    
+        m.file "paths.rb", "features/support/paths.rb"      
+      end
+      m.directory "features/support"
+      m.file "env.rb", "features/support/env.rb"   
+ 
+      m.directory "lib/tasks"
+      m.template "cucumber.rake", "lib/tasks/cucumber.rake"
+ 
+      m.file "cucumber", "script/cucumber", {
+        :chmod => 0755, :shebang => options[:shebang] == DEFAULT_SHEBANG ? nil : options[:shebang]
+      }
+    end
+  end
+  
+  def framework
+    options[:framework] || :rspec
+  end
+  
+protected
+ 
+  def banner
+    "Usage: #{$0} cucumber"
+  end
+    
+  def add_options!(opt)
+    opt.separator ""
+    opt.separator "Options:"
+    opt.on("-l", "--language=lang", String, "Use a [language] subdirectoy in /features.") { |v| options[:language] = v }
+   end
+   
+  # Load up the transations for the passed language, and modify the features_path accordingly
+  def set_language(language)
+    @features_path = File.join(@features_path, language)
+  end
+
+  def add_options!(opt)
+    opt.separator ''
+    opt.separator 'Options:'
+    opt.on('--rspec', 'Setup cucumber for use with RSpec (default)') do |value|
+      options[:framework] = :rspec
+    end
+
+    opt.on('--testunit', 'Setup cucumber for use with test/unit') do |value|
+      options[:framework] = :testunit
+    end
+  end
+
+end

data/rails_generators/cucumber/templates/cucumber

@@ -0,0 +1,8 @@
+#!/usr/bin/env ruby
+begin
+  load File.expand_path(File.dirname(__FILE__) + "/../vendor/plugins/cucumber/bin/cucumber")
+rescue LoadError => e
+  raise unless e.to_s =~ /cucumber/  
+  require "rubygems"
+  load File.join(Gem.bindir, "cucumber")
+end

data/rails_generators/cucumber/templates/cucumber.rake

@@ -0,0 +1,20 @@
+$LOAD_PATH.unshift(RAILS_ROOT + '/vendor/plugins/cucumber/lib') if File.directory?(RAILS_ROOT + '/vendor/plugins/cucumber/lib')
+
+begin
+  require 'cucumber/rake/task'
+
+  Cucumber::Rake::Task.new(:features) do |t|
+  <% if language %>
+    t.language = "<%= language%>"
+    t.cucumber_opts = "--format pretty --language <%= language%>"
+  <% else %>
+    t.cucumber_opts = "--format pretty"
+  <% end %>
+  end
+  task :features => 'db:test:prepare'
+rescue LoadError
+  desc 'Cucumber rake task not available'
+  task :features do
+    abort 'Cucumber rake task is not available. Be sure to install cucumber as a gem or plugin'
+  end
+end

data/rails_generators/cucumber/templates/env.rb

@@ -0,0 +1,17 @@
+# Sets up the Rails environment for Cucumber
+ENV["RAILS_ENV"] ||= "test"
+require File.expand_path(File.dirname(__FILE__) + '/../../config/environment')
+require 'cucumber/rails/world'
+require 'cucumber/formatters/unicode' # Comment out this line if you don't want Cucumber Unicode support
+Cucumber::Rails.use_transactional_fixtures
+
+require 'webrat'
+
+Webrat.configure do |config|
+  config.mode = :rails
+end
+<% if framework == :rspec -%>
+
+require 'cucumber/rails/rspec'
+require 'webrat/core/matchers'
+<% end -%>

data/rails_generators/cucumber/templates/paths.rb

@@ -0,0 +1,19 @@
+module NavigationHelpers
+  def path_to(page_name)
+    case page_name
+    
+    when /the homepage/i
+      root_path
+    
+    # Add more page name => path mappings here
+    
+    else
+      raise "Can't find mapping from \"#{page_name}\" to a path."
+    end
+  end
+end
+
+World do |world|
+  world.extend NavigationHelpers
+  world
+end

data/rails_generators/cucumber/templates/webrat_steps.rb

@@ -0,0 +1,115 @@
+require File.expand_path(File.join(File.dirname(__FILE__), "..", "support", "paths"))
+
+# Commonly used webrat steps
+# http://github.com/brynary/webrat
+
+Given /^I am on (.+)$/ do |page_name|
+  visit path_to(page_name)
+end
+
+When /^I go to (.+)$/ do |page_name|
+  visit path_to(page_name)
+end
+
+When /^I press "(.*)"$/ do |button|
+  click_button(button)
+end
+
+When /^I follow "(.*)"$/ do |link|
+  click_link(link)
+end
+
+When /^I fill in "(.*)" with "(.*)"$/ do |field, value|
+  fill_in(field, :with => value) 
+end
+
+When /^I select "(.*)" from "(.*)"$/ do |value, field|
+  select(value, :from => field) 
+end
+
+# Use this step in conjunction with Rail's datetime_select helper. For example:
+# When I select "December 25, 2008 10:00" as the date and time 
+When /^I select "(.*)" as the date and time$/ do |time|
+  select_datetime(time)
+end
+
+# Use this step when using multiple datetime_select helpers on a page or 
+# you want to specify which datetime to select. Given the following view:
+#   <%%= f.label :preferred %><br />
+#   <%%= f.datetime_select :preferred %>
+#   <%%= f.label :alternative %><br />
+#   <%%= f.datetime_select :alternative %>
+# The following steps would fill out the form:
+# When I select "November 23, 2004 11:20" as the "Preferred" data and time
+# And I select "November 25, 2004 10:30" as the "Alternative" data and time
+When /^I select "(.*)" as the "(.*)" date and time$/ do |datetime, datetime_label|
+  select_datetime(datetime, :from => datetime_label)
+end
+
+# Use this step in conjunction with Rail's time_select helper. For example:
+# When I select "2:20PM" as the time
+# Note: Rail's default time helper provides 24-hour time-- not 12 hour time. Webrat
+# will convert the 2:20PM to 14:20 and then select it. 
+When /^I select "(.*)" as the time$/ do |time|
+  select_time(time)
+end
+
+# Use this step when using multiple time_select helpers on a page or you want to
+# specify the name of the time on the form.  For example:
+# When I select "7:30AM" as the "Gym" time
+When /^I select "(.*)" as the "(.*)" time$/ do |time, time_label|
+  select_time(time, :from => time_label)
+end
+
+# Use this step in conjunction with Rail's date_select helper.  For example:
+# When I select "February 20, 1981" as the date
+When /^I select "(.*)" as the date$/ do |date|
+  select_date(date)
+end
+
+# Use this step when using multiple date_select helpers on one page or
+# you want to specify the name of the date on the form. For example:
+# When I select "April 26, 1982" as the "Date of Birth" date
+When /^I select "(.*)" as the "(.*)" date$/ do |date, date_label|
+  select_date(date, :from => date_label)
+end
+
+When /^I check "(.*)"$/ do |field|
+  check(field) 
+end
+
+When /^I uncheck "(.*)"$/ do |field|
+  uncheck(field) 
+end
+
+When /^I choose "(.*)"$/ do |field|
+  choose(field)
+end
+
+When /^I attach the file at "(.*)" to "(.*)"$/ do |path, field|
+  attach_file(field, path)
+end
+
+Then /^I should see "(.*)"$/ do |text|
+<% if framework == :rspec -%>
+  response.should contain(text)
+<% else -%>
+  assert_contain text
+<% end -%>
+end
+
+Then /^I should not see "(.*)"$/ do |text|
+<% if framework == :rspec -%>
+  response.should_not contain(text)
+<% else -%>
+  assert_not_contain text
+<% end -%>
+end
+
+Then /^the "(.*)" checkbox should be checked$/ do |label|
+<% if framework == :rspec -%>
+  field_labeled(label).should be_checked
+<% else -%>
+  assert field_labeled(label).checked?
+<% end -%>
+end