nofxx-watircuke 0.2.2

data/.gitignore

@@ -0,0 +1,2 @@
+.DS_Store
+pkg/

data/README

@@ -0,0 +1,64 @@
+= Watircuke 
+
+
+== INSTALL
+
+Cucumber:
+http://wiki.github.com/aslakhellesoy/cucumber/install
+
+Watir ~ Firewatir ~ Safariwatir:
+http://wtr.rubyforge.org/install.html
+
+Once installed just run "cucumber features" in Safari, Firefox, Watir (see features/support/env.rb)
+
+
+== Rails
+
+Supposing your webrat features are on features/plain, Watir on features/watir and 
+you remove step_definitions/webrat_steps.rb (don't worry, steps will be included), 
+you can run `cucumber` for plain webrat and `cucumber -p watir` for some Watir =D
+
+cucumber.yml
+    
+    default: -r features/support/env.rb -r features/support/webrat.rb -r features/step_definitions features/plain
+    watir:   -r features/support/env.rb -r features/support/watir.rb -r features/step_definitions features/watir
+
+
+support/watir.rb
+
+    require 'watircuke'
+    Before do
+      @environment = "http://localhost:3000/
+      sleep 1
+    end
+    # optional
+    # at_exit do
+    #   @browser.close
+    # end
+
+
+support/webrat.rb
+
+    require 'webrat'
+    Webrat.configure do |config|
+      config.mode = :rails
+    end
+    require 'cucumber/rails/rspec'
+    require 'webrat/core/matchers'
+    require 'webratcuke'
+
+
+support/env.rb
+
+    ENV["RAILS_ENV"] ||= "cucumber"
+    require File.expand_path(File.dirname(__FILE__) + '/../../config/environment')
+    require 'cucumber/rails/world'
+    require 'cucumber/formatter/unicode' # Comment out this line if you don't want Cucumber Unicode support
+    Cucumber::Rails.use_transactional_fixtures
+    Cucumber::Rails.bypass_rescue # Comment out this line if you want Rails own error handling
+        
+== TODO
+
+Rewrite the watir steps to resemble webrat's ones.
+
+**cukewatir maximizes the Gherkin speak and minimizes the Watir code.    

data/Rakefile

@@ -0,0 +1,48 @@
+require 'rubygems'
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "watircuke"
+    gem.summary = "Watir steps for cucumber"
+    gem.email = "x@nofxx.com"
+    gem.homepage = "http://github.com/nofxx/watircuke"
+    gem.authors = ["Rich Downie", "Marcos Piccinini"]
+    # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
+  end
+
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: sudo gem install jeweler"
+end
+
+require 'spec/rake/spectask'
+Spec::Rake::SpecTask.new(:spec) do |spec|
+  spec.libs << 'lib' << 'spec'
+  spec.spec_files = FileList['spec/**/*_spec.rb']
+end
+
+Spec::Rake::SpecTask.new(:rcov) do |spec|
+  spec.libs << 'lib' << 'spec'
+  spec.pattern = 'spec/**/*_spec.rb'
+  spec.rcov = true
+end
+
+
+task :default => :spec
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  if File.exist?('VERSION.yml')
+    config = YAML.load(File.read('VERSION.yml'))
+    version = "#{config[:major]}.#{config[:minor]}.#{config[:patch]}"
+  else
+    version = ""
+  end
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "watircuke #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+

data/VERSION

@@ -0,0 +1 @@
+0.2.2

data/features/sample.feature

@@ -0,0 +1,10 @@
+Feature: Github
+  
+  Scenario: search for cucumber at github
+    Given I am on the watircuke page
+    Then I verify the page contains the text "richdownie"
+    And I fill in the text field "q" with "cucumber"
+    And I click the "Search" button
+    And I select "Code" from the select list "type_value"
+    And I click the "aslakhellesoy / cucumber" link
+    Then I verify the page contains the text "BDD that talks to domain experts first and code second"

data/features/step_definitions/assertions.rb

@@ -0,0 +1,23 @@
+Given /I verify the page contains the text "(.*)"/ do |text|
+  assert(@browser.contains_text(text))
+end
+
+Given /I verify the page does not contain the text "(.*)"/ do |text|
+  assert_false(@browser.contains_text(text))
+end
+
+Given /I verify the page contains a div class "(.*)"/ do |byclass|
+  assert(@browser.div(:class, byclass).exists?)
+end
+
+Given /I verify the page contains a div id "(.*)"/ do |id|
+  assert(@browser.div(:id, id).exists?)
+end
+
+Given /I verify the page contains a link class "(.*)"/ do |byclass|
+  assert(@browser.link(:class, byclass).exists?)
+end
+
+Given /I verify the page contains the image "(.*)"/ do |image|
+  assert(@browser.image(:src, image).exists?)
+end

data/features/step_definitions/buttons.rb

@@ -0,0 +1,3 @@
+Given /I click the "(.*)" button/ do |value|
+  @browser.button(:value, value).click
+end

data/features/step_definitions/checkboxes.rb

@@ -0,0 +1,3 @@
+Given /I click the "(.*)" checkbox/ do |id|
+  @browser.checkbox(:id, id).click
+end

data/features/step_definitions/javascript.rb

@@ -0,0 +1,3 @@
+Given /From the "(.*)" link I fire the "(.*)" event/  do |text, event|
+  @browser.link(:text , text).fire_event(event)
+end

data/features/step_definitions/links.rb

@@ -0,0 +1,3 @@
+Given /I click the "(.*)" link/  do |text|
+  @browser.link(:text, text).click
+end

data/features/step_definitions/pages.rb

@@ -0,0 +1,3 @@
+Given /^I am on (.+)$/ do |page_name|
+  @browser.goto(path_to(page_name))
+end

data/features/step_definitions/radio_buttons.rb

@@ -0,0 +1,3 @@
+Given /I click the "(.*)" radio button/ do |id|
+  @browser.radio(:id, id).click
+end

data/features/step_definitions/select_lists.rb

@@ -0,0 +1,3 @@
+Given /I select "(.*)" from the select list "(.*)"/ do |value, id|
+  @browser.select_list(:id, id).select(value)
+end

data/features/step_definitions/sleep.rb

@@ -0,0 +1,3 @@
+Given /I wait "(.*)" seconds/ do |time|
+  sleep time.to_i
+end

data/features/step_definitions/spans.rb

@@ -0,0 +1,3 @@
+Given /I click the "(.*)" span/  do |text|
+  @browser.span(:text, text).click
+end

data/features/step_definitions/text_fields.rb

@@ -0,0 +1,4 @@
+Given /I fill in the text field "(.*)" with "(.*)"/ do |name, text|
+  @browser.text_field(:name, name).set(text)
+end
+

data/features/step_definitions/urls.rb

@@ -0,0 +1,3 @@
+Given /I visit "(.*)"/ do |text|
+  @browser.goto(@environment + text)
+end

data/features/support/env.rb

@@ -0,0 +1,39 @@
+require 'test/unit/assertions'
+include Test::Unit::Assertions
+require 'spec'
+
+if ENV['FIREWATIR']
+  require 'firewatir'
+  Browser = FireWatir::Firefox
+else
+  case RUBY_PLATFORM
+  when /darwin|i686-linux/
+    require 'firewatir'
+    Browser = FireWatir::Firefox
+    # 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
+end
+
+
+ # "before all"
+ browser = Browser.new
+
+ Before do
+   @browser = browser
+   @environment = "http://github.com/"
+   sleep 3
+ end
+
+ # "after all"
+ at_exit do
+   # @browser.close
+ end

data/features/support/paths.rb

@@ -0,0 +1,22 @@
+module NavigationHelpers
+  def path_to(page_name)
+    case page_name
+    
+    when /the guides page/i
+      @environment + "guides/home"
+
+    when /the watircuke page/i
+      @environment + "richdownie/watircuke/tree/master"
+            
+    # Add more page name => path mappings here
+    
+    else
+      raise "Can't find mapping from \"#{page_name}\" to a path.\n" +
+        "Now, go and add a mapping in features/support/paths.rb"
+    end
+  end
+end
+
+World do 
+  extend NavigationHelpers
+end

data/lib/watircuke.rb

@@ -0,0 +1,117 @@
+require "cucumber"
+require 'spec'
+#require File.join(File.dirname(__FILE__), '..', 'features', 'support', 'env')
+# Dir[File.join(File.dirname(__FILE__), '..', 'features', 'step_definitions', '*rb')].each { |file| require file }
+
+if ENV['FIREWATIR']
+  require 'firewatir'
+  Browser = FireWatir::Firefox
+else
+  case RUBY_PLATFORM
+  when /darwin|i686-linux/
+    require 'firewatir'
+    Browser = FireWatir::Firefox
+    # 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
+end
+
+# "before all"
+#browser =
+
+Before do
+  @browser = Browser.new
+end
+
+When /^I press "([^\"]*)"$/ do |b|
+  @browser.button(:value, b).click
+end
+
+When /^I follow "([^\"]*)"$/ do |l|
+  @browser.link(:text, l).click
+end
+
+When /^I (visit|go to) the (.+)$/ do |_, text|
+  @browser.goto(@environment + text)
+end
+
+Given /^I am on (.+)$/ do |page_name|
+  @browser.goto(path_to(page_name))
+end
+
+#
+# Should see
+#
+Then /^I should see "([^\"]*)"$/ do |text|
+  @browser.contains_text(text).should be_true
+end
+
+Then /^I should not see "([^\"]*)"$/ do |text|
+  @browser.contains_text(text).should be_false
+end
+
+Then /^I should see "([^\"]*)" (\d+) times*$/ do |text, count|
+  res = response.body
+  (count.to_i - 1).times { res.sub!(/#{text}/, "")}
+  res.should contain(text)
+  res.sub(/#{text}/, "").should_not contain(text)
+end
+
+Given /I verify the page contains a div class "(.*)"/ do |byclass|
+  @browser.div(:class, byclass).exists?.should be_true
+end
+
+Given /I verify the page contains a div id "(.*)"/ do |id|
+  @browser.div(:id, id).exists?.should be_true
+end
+
+Given /I verify the page contains a link class "(.*)"/ do |byclass|
+  @browser.link(:class, byclass).exists?.should be_true
+end
+
+Given /I verify the page contains the image "(.*)"/ do |image|
+  @browser.image(:src, image).exists?.should be_true
+end
+
+#
+# Forms
+#
+When /^I fill in "([^\"]*)" with "([^\"]*)"$/ do |field, value|
+  @browser.text_field(:name, field).set(value)
+end
+
+# When /^I select "([^\"]*)" from "([^\"]*)"$/ do |value, field|
+#   select(value, :from => field)
+# end
+
+# Given /I click the "(.*)" checkbox/ do |id|
+#   @browser.checkbox(:id, id).click
+# end
+
+Given /I click the "(.*)" radio button/ do |id|
+  @browser.radio(:id, id).click
+end
+
+Given /I select "(.*)" from the select list "(.*)"/ do |value, id|
+  @browser.select_list(:id, id).select(value)
+end
+
+Given /From the "(.*)" link I fire the "(.*)" event/  do |text, event|
+  @browser.link(:text , text).fire_event(event)
+end
+
+Given /I wait "(.*)" seconds/ do |time|
+  sleep time.to_i
+end
+
+Given /I click the "(.*)" span/  do |text|
+  @browser.span(:text, text).click
+end

data/lib/webratcuke.rb

@@ -0,0 +1,181 @@
+# 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
+
+When /^I (press|follow|check|uncheck|choose) "([^\"]*)" for (.*) whose (.*) is "([^\"]*)"$/ do |action, whatyouclick, class_name, var_name, value|
+  id = var_name == "id" ? value : eval("\"#{class_name}\".classify.constantize.find_by_#{var_name}(\"#{value}\").id.to_s")
+  within("tr[id=row_#{class_name}_#{id}]") do
+    case action
+      when "press"   then   click_button(whatyouclick)
+      when "follow"  then   click_link(whatyouclick)
+      when "check"   then   check(whatyouclick)
+      when "uncheck" then   uncheck(whatyouclick)
+      when "choose"  then   uncheck(whatyouclick)
+    end
+  end
+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" date and time
+# And I select "November 25, 2004 10:30" as the "Alternative" date 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|
+  response.should contain(text)
+end
+
+Then /^I should see "([^\"]*)" (\d+) times*$/ do |text, count|
+  res = response.body
+  (count.to_i - 1).times { res.sub!(/#{text}/, "")}
+  res.should contain(text)
+  res.sub(/#{text}/, "").should_not contain(text)
+end
+
+
+Then /^I should not see "([^\"]*)"$/ do |text|
+  response.should_not contain(text)
+end
+
+Then /^the "([^\"]*)" field should contain "([^\"]*)"$/ do |field, value|
+  field_labeled(field).value.should =~ /#{value}/
+end
+
+Then /^the "([^\"]*)" field should not contain "([^\"]*)"$/ do |field, value|
+  field_labeled(field).value.should_not =~ /#{value}/
+end
+
+Then /^the "([^\"]*)" checkbox should be checked$/ do |label|
+  field_labeled(label).should be_checked
+end
+
+Then /^I should be on (.+)$/ do |page_name|
+  URI.parse(current_url).path.should == path_to(page_name)
+end
+
+# Steps that are generally useful and help encourage use of semantic
+# IDs and Class Names in your markup. In the steps below, a match following
+# "the" will verify the presences of an element with a given ID while a match following
+# "a" or "an" will verify the presence an element of a given class.
+Then /^I debug$/ do
+  debugger
+end
+
+Then /^save_and_open_page$/ do
+  save_and_open_page
+end
+
+Then /^I wait for ([0-9]+) seconds$/ do |delay|
+  sleep delay.to_i
+end
+
+Then /^I should see a (\S+) in the (\S+)$/ do |element, containing_element|
+  response.should have_tag("##{containing_element} .#{element}")
+end
+
+Then /^I should see the (\S+) in the (\S+)$/ do |element, containing_element|
+  response.should have_tag("##{containing_element} ##{element}")
+end
+
+Then /^I should see (\d+) (\S+) in the (\S+)$/ do |count, element, containing_element|
+  response.should have_tag("##{containing_element} .#{element.singularize}",:count => count.to_i)
+end
+
+Then /^I should see (\d+) to (\d+) (\S+) in the (\S+)$/ do |min, max, element, containing_element|
+  response.should have_tag("##{containing_element} .#{element.singularize}",min.to_i..max.to_i)
+end
+
+Then /^the (\S+) in the (\S+) should contain (a|an|the) (\S+)$/ do |middle_element, outer_element, a, inner_element|
+  response.should have_tag("##{outer_element} .#{middle_element} .#{inner_element}")
+end
+
+Then /^I should see the (\S+)$/ do |element_id|
+  response.should have_tag("##{element_id}")
+end
+
+Then /^I should see (a|an) (\S+)$/ do |a, element_class|
+  response.should have_tag(".#{element_class}")
+end

data/spec/spec_helper.rb

@@ -0,0 +1,10 @@
+require 'rubygems'
+require 'spec'
+
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+require 'watircuke'
+
+Spec::Runner.configure do |config|
+
+end

data/spec/watircuke_spec.rb

@@ -0,0 +1,7 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe "Watircuke" do
+  it "should open ffox" do
+     puts "Opening ffox!"
+  end
+end

data/watircuke.gemspec

@@ -0,0 +1,59 @@
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{watircuke}
+  s.version = "0.2.2"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Rich Downie", "Marcos Piccinini"]
+  s.date = %q{2009-06-16}
+  s.email = %q{x@nofxx.com}
+  s.extra_rdoc_files = [
+    "README"
+  ]
+  s.files = [
+    ".gitignore",
+     "README",
+     "Rakefile",
+     "VERSION",
+     "features/sample.feature",
+     "features/step_definitions/assertions.rb",
+     "features/step_definitions/buttons.rb",
+     "features/step_definitions/checkboxes.rb",
+     "features/step_definitions/javascript.rb",
+     "features/step_definitions/links.rb",
+     "features/step_definitions/pages.rb",
+     "features/step_definitions/radio_buttons.rb",
+     "features/step_definitions/select_lists.rb",
+     "features/step_definitions/sleep.rb",
+     "features/step_definitions/spans.rb",
+     "features/step_definitions/text_fields.rb",
+     "features/step_definitions/urls.rb",
+     "features/support/env.rb",
+     "features/support/paths.rb",
+     "lib/watircuke.rb",
+     "lib/webratcuke.rb",
+     "spec/spec_helper.rb",
+     "spec/watircuke_spec.rb",
+     "watircuke.gemspec"
+  ]
+  s.homepage = %q{http://github.com/nofxx/watircuke}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.4}
+  s.summary = %q{Watir steps for cucumber}
+  s.test_files = [
+    "spec/watircuke_spec.rb",
+     "spec/spec_helper.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+    else
+    end
+  else
+  end
+end

metadata

@@ -0,0 +1,78 @@
+--- !ruby/object:Gem::Specification 
+name: nofxx-watircuke
+version: !ruby/object:Gem::Version 
+  version: 0.2.2
+platform: ruby
+authors: 
+- Rich Downie
+- Marcos Piccinini
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-06-16 00:00:00 -07:00
+default_executable: 
+dependencies: []
+
+description: 
+email: x@nofxx.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README
+files: 
+- .gitignore
+- README
+- Rakefile
+- VERSION
+- features/sample.feature
+- features/step_definitions/assertions.rb
+- features/step_definitions/buttons.rb
+- features/step_definitions/checkboxes.rb
+- features/step_definitions/javascript.rb
+- features/step_definitions/links.rb
+- features/step_definitions/pages.rb
+- features/step_definitions/radio_buttons.rb
+- features/step_definitions/select_lists.rb
+- features/step_definitions/sleep.rb
+- features/step_definitions/spans.rb
+- features/step_definitions/text_fields.rb
+- features/step_definitions/urls.rb
+- features/support/env.rb
+- features/support/paths.rb
+- lib/watircuke.rb
+- lib/webratcuke.rb
+- spec/spec_helper.rb
+- spec/watircuke_spec.rb
+- watircuke.gemspec
+has_rdoc: false
+homepage: http://github.com/nofxx/watircuke
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 3
+summary: Watir steps for cucumber
+test_files: 
+- spec/watircuke_spec.rb
+- spec/spec_helper.rb