tchandy-watircuke 0.4.1

data/.gitignore

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

data/README.rdoc

@@ -0,0 +1,62 @@
+= Watircuke
+
+Webrat & Watir Family common (and some cool) steps as a gem.
+
+
+== Install
+
+Cucumber::   http://wiki.github.com/aslakhellesoy/cucumber/install
+Watir ~ Firewatir ~ Safariwatir::  http://wtr.rubyforge.org/install.html
+
+
+== Use
+
+* Remove step_definitions/webrat_steps.rb if you have it.
+
+* In the scenarios you want to run watir, just add the @watir tag before.
+
+* Run `cucumber` for webrat and `cucumber -p watir` for some Watir =D
+
+
+== Rails Sample
+
+
+cucumber.yml
+
+    default: CUC_ENV=webrat -r features/support/env.rb features -t ~watir
+    watir: CUC_ENV=watir  -r features/support/env.rb features -t  watir
+
+
+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
+
+    if ENV['CUC_ENV'] == 'watir'
+      require 'watircuke'
+      Before do
+        @environment = "http://localhost:3000/
+        sleep 1
+      end
+      # optional
+      # at_exit do
+      #   @browser.close
+      # end
+    else
+      require 'webrat'
+      Webrat.configure do |config|
+        config.mode = :rails
+      end
+      require 'cucumber/rails/rspec'
+      require 'webrat/core/matchers'
+      require 'webratcuke'
+    end
+
+
+== ABOUT
+
+**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.4

data/cucumber.yml

@@ -0,0 +1,2 @@
+default: CUC_ENV=watir -r features/support/env.rb features -t ~webrat
+webrat: CUC_ENV=webrat -r features/support/env.rb features -t webrat

data/features/ajax.feature

@@ -0,0 +1,15 @@
+Feature: Ajax
+
+  @watir
+  Scenario: ajaxy test
+    Given I am on the watircuke page
+    And I click "download_button"
+    And I wait until "facebox"
+    And I wait until "archives"
+    Then I should see "Download richdownie/watircuke at master "
+
+  @watir
+  Scenario: ajaxy search
+    Given I am on bing
+    And I fill in "q" with "cucu"
+    Then I should see "cucumber"

data/features/sample.feature

@@ -0,0 +1,11 @@
+Feature: Github
+
+  Scenario: search for cucumber at github
+    Given I am on the cucumber page
+    Then I should see "BDD that talks to domain experts first and code second"
+    When I fill in "q" with "watircuke"
+    And I press "Search"
+    And I select "Code" from "type_value"
+    Then I should see "Repositories"
+    When I follow "richdownie / watircuke"
+    Then I should see "H30 (watir, safariwatir, firewatir)"

data/features/support/env.rb

@@ -0,0 +1,20 @@
+require 'spec'
+require File.expand_path(File.dirname(__FILE__) + '/paths')
+
+if ENV['CUC_ENV'] == 'webrat'
+  require 'webrat/core/matchers'
+  require File.expand_path(File.dirname(__FILE__) + '/../../lib/webratcuke')
+else
+  require File.expand_path(File.dirname(__FILE__) + '/../../lib/watircuke')
+
+  Before do
+    @environment = "http://github.com/"
+    #  sleep 1
+  end
+
+  # FIXME: this doesn't work
+  # After do
+  #   @browser.close if @browser
+  # end
+
+end

data/features/support/paths.rb

@@ -0,0 +1,25 @@
+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"
+    when /the cucumber page/i
+      @environment + "aslakhellesoy/cucumber/tree/master"
+    when /the homepage/i
+      @environment
+    when /bing/i
+      "http://bing.com"
+
+    # 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(NavigationHelpers)

data/lib/steps/watircuke_en.rb

@@ -0,0 +1,114 @@
+module Watircuke
+  module Steps
+    module EN
+      #
+      # Browsing
+      #
+      Given /^I am on (.+)$/ do |page_name|
+        @browser.goto(path_to(page_name))
+      end
+
+      When /^I (visit|go to) the (.+)$/ do |_, text|
+        @browser.goto(@environment + text)
+      end
+
+      When /^I (click|follow) "([^\"]*)"$/ do |_, id|
+        link = @browser.link(:text, id).click rescue @browser.link(:id, id).click
+      end
+
+      Then /^I should be on (.+)$/ do |page_name|
+        URI.parse(@browser.url).path.should == 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 = @browser.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
+
+      Then /^the "([^\"]*)" checkbox should be checked$/ do |label|
+        @browser.checkbox(label).should be_checked
+      end
+
+      #
+      # Forms
+      #
+      #
+      When /^I press "([^\"]*)"$/ do |b|
+        @browser.button(:value, b).click
+      end
+
+      When /^I fill in "([^\"]*)" with "([^\"]*)"$/ do |field, value|
+        @browser.text_field(:name, field).set(value) rescue @browser.text_field(:id, field).set(value)
+      end
+
+      When /^I select "([^\"]*)" from "([^\"]*)"$/ do |value, id|
+        @browser.select_list(:id, id).select(value)
+      end
+
+      When /^I choose "([^\"]*)"$/ do |id|
+        @browser.radio(:id, id).click
+      end
+
+      When /^I check "([^\"]*)"$/ do |id|
+        @browser.checkbox(:id, id).click
+      end
+
+      When /^I uncheck "([^\"]*)"$/ do |id|
+        @browser.checkbox(field).clear
+      end
+
+      #
+      # Javascript
+      #
+      Given /From the "(.*)" link I fire the "(.*)" event/  do |text, event|
+        @browser.link(:text , text).fire_event(event)
+      end
+
+      Given /I click the "(.*)" span/  do |text|
+        @browser.span(:text, text).click
+      end
+
+      Given /I wait (\d+) seconds*/ do |time|
+        sleep time.to_i
+      end
+
+      Given /^I wait until "([^\"]*)"$/ do |div|
+        7.times do |i|
+          break if @browser.div(:id, div).exists?
+          i == 7 ? raise(Watir::Exception::UnknownObjectException) : sleep(1)
+        end
+      end
+
+    end
+  end
+end

data/lib/steps/watircuke_pt.rb

@@ -0,0 +1,114 @@
+# -*- coding: utf-8 -*-
+module Watircuke
+  module Steps
+    module PT
+      #
+      # Navegando
+      #
+      Given /^Eu estou em (.+)$/ do |page_name|
+        @browser.goto(path_to(page_name))
+      end
+
+      When /^Eu (visito|vou) para (.+)$/ do |_, text|
+        @browser.goto(@environment + text)
+      end
+
+      When /^Eu (clico|sigo) "([^\"]*)"$/ do |_, id|
+        link = @browser.link(:text, id).click rescue @browser.link(:id, id).click
+      end
+
+      Then /^Eu devo estar em (.+)$/ do |page_name|
+        URI.parse(@browser.url).path.should == path_to(page_name)
+      end
+
+      #
+      # Devo ver
+      #
+      #
+      Then /^Eu devo ver "([^\"]*)"$/ do |text|
+        @browser.contains_text(text).should be_true
+      end
+
+      Then /^Eu não devo ver "([^\"]*)"$/ do |text|
+        @browser.contains_text(text).should be_false
+      end
+
+      # Then /^I should see "([^\"]*)" (\d+) times*$/ do |text, count|
+      #   res = @browser.body
+      #   (count.to_i - 1).times { res.sub!(/#{text}/, "")}
+      #   res.should contain(text)
+      #   res.sub(/#{text}/, "").should_not contain(text)
+      # end
+
+      Given /Eu verifico que a página contêm uma div com a class "(.*)"/ do |byclass|
+        @browser.div(:class, byclass).exists?.should be_true
+      end
+
+      Given /Eu verifico que a página contêm uma div com a id "(.*)"/ do |id|
+        @browser.div(:id, id).exists?.should be_true
+      end
+
+      Given /Eu verifico que a página contêm um link com a class "(.*)"/ do |byclass|
+        @browser.link(:class, byclass).exists?.should be_true
+      end
+
+      Given /Eu verifico que a página contêm a imagem "(.*)"/ do |image|
+        @browser.image(:src, image).exists?.should be_true
+      end
+
+      Then /^o checkbox "([^\"]*)" deve estar marcado$/ do |label|
+        @browser.checkbox(label).should be_checked
+      end
+
+      #
+      # Formulários
+      #
+      #
+      When /^Eu pressiono "([^\"]*)"$/ do |b|
+        @browser.button(:value, b).click
+      end
+
+      When /^Eu preeencho "([^\"]*)" com "([^\"]*)"$/ do |field, value|
+        @browser.text_field(:name, field).set(value) rescue @browser.text_field(:id, field).set(value)
+      end
+
+      When /^Eu seleciono "([^\"]*)" em "([^\"]*)"$/ do |value, id|
+        @browser.select_list(:id, id).select(value)
+      end
+
+      When /^Eu seleciono "([^\"]*)"$/ do |id|
+        @browser.radio(:id, id).click
+      end
+
+      When /^Eu marco "([^\"]*)"$/ do |id|
+        @browser.checkbox(:id, id).click
+      end
+
+      When /^Eu desmarco "([^\"]*)"$/ do |id|
+        @browser.checkbox(field).clear
+      end
+
+      #
+      # Javascript
+      #
+      Given /Do link "(.*)" Eu chamo o evento "(.*)"/  do |text, event|
+        @browser.link(:text , text).fire_event(event)
+      end
+
+      Given /Eu clico no span "(.*)"/  do |text|
+        @browser.span(:text, text).click
+      end
+
+      Given /Eu espero por (\d+) segundos*/ do |time|
+        sleep time.to_i
+      end
+
+      Given /^Eu espero até "([^\"]*)"$/ do |div|
+        7.times do |i|
+          break if @browser.div(:id, div).exists?
+          i == 7 ? raise(Watir::Exception::UnknownObjectException) : sleep(1)
+        end
+      end
+    end
+  end
+end

data/lib/steps/webratcuke_en.rb

@@ -0,0 +1,196 @@
+# Watircuke
+#
+# Commonly used webrat steps
+# http://github.com/brynary/webrat
+#
+
+#
+# Browsing
+#
+#
+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 follow "([^\"]*)"$/ do |link|
+  click_link(link)
+end
+
+Then /^I should be on (.+)$/ do |page_name|
+  URI.parse(current_url).path.should == path_to(page_name)
+end
+
+#
+# Should see
+#
+#
+Then /^I should see "([^\"]*)"$/ do |text|
+  response.should contain(text)
+end
+
+Then /^I should not see "([^\"]*)"$/ do |text|
+  response.should_not 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 /^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 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
+
+
+#
+# Forms
+#
+#
+When /^I press "([^\"]*)"$/ do |button|
+  click_button(button)
+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 choose "([^\"]*)"$/ do |field|
+  choose(field)
+end
+
+When /^I check "([^\"]*)"$/ do |field|
+  check(field)
+end
+
+When /^I uncheck "([^\"]*)"$/ do |field|
+  uncheck(field)
+end
+
+When /^I attach the file at "([^\"]*)" to "([^\"]*)"$/ do |path, field|
+  attach_file(field, path)
+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
+

data/lib/watircuke.rb

@@ -0,0 +1,41 @@
+#
+# Watircuke
+#
+# Commonly used watir steps
+#
+#
+require 'cucumber'
+require 'spec'
+
+#
+# Environment
+#
+if ENV['FIREWATIR']
+  require 'firewatir'
+  Browser = FireWatir::Firefox
+else
+  case RUBY_PLATFORM
+  when /darwin/
+    require 'firewatir'
+    Browser = FireWatir::Firefox
+  when /linux/
+    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
+
+#
+# Cucumber
+#
+Before do
+  @browser = Browser.new
+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,51 @@
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{watircuke}
+  s.version = "0.4.1"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Rich Downie", "Marcos Piccinini", "Thiago Pradi"]
+  s.date = %q{2009-06-19}
+  s.email = %q{x@nofxx.com}
+  s.extra_rdoc_files = [
+    "README.rdoc"
+  ]
+  s.files = [
+    ".gitignore",
+     "README.rdoc",
+     "Rakefile",
+     "VERSION",
+     "cucumber.yml",
+     "features/ajax.feature",
+     "features/sample.feature",
+     "features/support/env.rb",
+     "features/support/paths.rb",
+     "lib/watircuke.rb",
+     "lib/steps/watircuke_en.rb",
+     "lib/steps/watircuke_pt.rb",
+     "lib/steps/webratcuke_en.rb",
+     "spec/spec_helper.rb",
+     "spec/watircuke_spec.rb",
+     "watircuke.gemspec"
+  ]
+  s.homepage = %q{http://github.com/tchandy/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,71 @@
+--- !ruby/object:Gem::Specification 
+name: tchandy-watircuke
+version: !ruby/object:Gem::Version 
+  version: 0.4.1
+platform: ruby
+authors: 
+- Rich Downie
+- Marcos Piccinini
+- Thiago Pradi
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-06-19 00:00:00 -07:00
+default_executable: 
+dependencies: []
+
+description: 
+email: x@nofxx.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.rdoc
+files: 
+- .gitignore
+- README.rdoc
+- Rakefile
+- VERSION
+- cucumber.yml
+- features/ajax.feature
+- features/sample.feature
+- features/support/env.rb
+- features/support/paths.rb
+- lib/watircuke.rb
+- lib/steps/watircuke_en.rb
+- lib/steps/watircuke_pt.rb
+- lib/steps/webratcuke_en.rb
+- spec/spec_helper.rb
+- spec/watircuke_spec.rb
+- watircuke.gemspec
+has_rdoc: false
+homepage: http://github.com/tchandy/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