cucumber 0.1.6

data/gem_tasks/fix_cr_lf.rake

@@ -0,0 +1,10 @@
+desc 'Make all files use UNIX (\n) line endings'
+task :fix_cr_lf do
+  files = FileList['**/*']
+  files.each do |f|
+    next if File.directory?(f)
+    s = IO.read(f)
+    s.gsub!(/\r?\n/, "\n")
+    File.open(f, "w") { |io| io.write(s) }
+  end
+end

data/gem_tasks/flog.rake

@@ -0,0 +1,4 @@
+desc "Run flog over significant files"
+task :flog do
+  sh "find lib -name \\*.rb | grep -v feature_..\\.rb | xargs flog"
+end

data/gem_tasks/gemspec.rake

@@ -0,0 +1,6 @@
+namespace :gemspec do
+  desc 'Refresh cucumber.gemspec to include ALL files'
+  task :refresh => 'manifest:refresh' do
+    File.open('cucumber.gemspec', 'w') {|io| io.write($hoe.spec.to_ruby)}
+  end
+end

data/gem_tasks/rspec.rake

@@ -0,0 +1,21 @@
+begin
+  require 'spec'
+rescue LoadError
+  require 'rubygems'
+  require 'spec'
+end
+begin
+  require 'spec/rake/spectask'
+rescue LoadError
+  puts <<-EOS
+To use rspec for testing you must install rspec gem:
+    gem install rspec
+EOS
+  exit(0)
+end
+
+desc "Run the specs under spec/models"
+Spec::Rake::SpecTask.new do |t|
+  t.spec_opts = ['--options', "spec/spec.opts"]
+  t.spec_files = FileList['spec/**/*_spec.rb']
+end

data/gem_tasks/treetop.rake

@@ -0,0 +1,27 @@
+class FeatureCompiler
+  def compile
+    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')
+
+    langs.each do |lang, words|
+      grammar_file = File.dirname(__FILE__) + "/../lib/cucumber/treetop_parser/feature_#{lang}.treetop"
+      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
+end
+
+namespace :treetop do
+  desc 'Compile the grammar for all languages in languages.yml'
+  task :compile do
+    FeatureCompiler.new.compile
+  end
+end

data/generators/cucumber/cucumber_generator.rb

@@ -0,0 +1,27 @@
+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'])
+  def manifest
+    record do |m|
+      script_options     = { :chmod => 0755, :shebang => options[:shebang] == DEFAULT_SHEBANG ? nil : options[:shebang] }
+
+      m.directory 'features/steps'
+      m.file      'env.rb', 'features/steps/env.rb'
+      m.file      'common_webrat.rb', 'features/steps/common_webrat.rb'
+
+      m.directory 'lib/tasks'
+      m.file      'cucumber.rake', 'lib/tasks/cucumber.rake'
+      m.file      'cucumber',      'script/cucumber',        script_options
+    end
+  end
+
+protected
+
+  def banner
+    "Usage: #{$0} cucumber"
+  end
+
+end

data/generators/cucumber/templates/common_webrat.rb

@@ -0,0 +1,51 @@
+# Commonly used webrat steps
+# http://github.com/brynary/webrat
+
+When /^I press "(.*)"$/ do |button|
+  clicks_button(button)
+end
+
+When /^I follow "(.*)"$/ do |link|
+  clicks_link(link)
+end
+
+When /^I fill in "(.*)" with "(.*)"$/ do |field, value|
+  fills_in(field, :with => value) 
+end
+
+When /^I select "(.*)" from "(.*)"$/ do |field, value|
+  selects(field, :with => value) 
+end
+
+When /^I check "(.*)"$/ do |field|
+  checks(field) 
+end
+
+When /^I uncheck "(.*)"$/ do |field|
+  unchecks(field) 
+end
+
+When /^I choose "(.*)"$/ do |field|
+  chooses(field)
+end
+
+When /^I attach the file at "(.*)" to "(.*)" $/ do |path, field|
+  attaches_file(field, path)
+end
+
+When /^I go to (.*)$/ do |page|
+  visits case page
+  when "the home page"
+    "/"
+  else
+    raise "Can't find mapping from \"#{page}\" to a path"
+  end
+end
+
+Then /^I should see "(.*)"$/ do |text|
+  response.body.should =~ /#{text}/m
+end
+
+Then /^I should not see "(.*)"$/ do |text|
+  response.body.should_not =~ /#{text}/m
+end

data/generators/cucumber/templates/cucumber

@@ -0,0 +1,2 @@
+#!/usr/bin/env ruby
+load File.expand_path(File.dirname(__FILE__) + "/../vendor/plugins/cucumber/bin/cucumber")

data/generators/cucumber/templates/cucumber.rake

@@ -0,0 +1,7 @@
+$:.unshift(RAILS_ROOT + '/vendor/plugins/cucumber/lib')
+require 'cucumber/rake/task'
+
+Cucumber::Rake::Task.new(:features) do |t|
+  t.cucumber_opts = "--format pretty"
+end
+task :features => 'db:test:prepare'

data/generators/cucumber/templates/env.rb

@@ -0,0 +1,8 @@
+# Sets up the Rails environment for Cucumber
+ENV["RAILS_ENV"] = "test"
+require File.expand_path(File.dirname(__FILE__) + '/../../config/environment')
+require 'cucumber/rails/world'
+Cucumber::Rails.use_transactional_fixtures
+
+# Comment out the next line if you're not using RSpec's matchers (should / should_not) in your steps.
+require 'cucumber/rails/rspec'

data/generators/feature/feature_generator.rb

@@ -0,0 +1,17 @@
+# This generator bootstraps a Rails project for use with Cucumber
+class FeatureGenerator < Rails::Generator::NamedBase
+  def manifest
+    record do |m|
+      m.directory 'features/steps'
+      m.template  'feature.erb', "features/manage_#{plural_name}.feature"
+      m.template  'steps.erb', "features/steps/#{singular_name}_steps.rb"
+    end
+  end
+
+protected
+
+  def banner
+    "Usage: #{$0} cucumber"
+  end
+
+end

data/generators/feature/templates/feature.erb

@@ -0,0 +1,27 @@
+Feature: Manage <%= plural_name %>
+  In order to keep track of <%= plural_name %>
+  A <%= singular_name %> mechanic
+  Should be able to manage several <%= plural_name %>
+  
+  Scenario: Register new <%= singular_name %>
+    Given I am on the new <%= singular_name %> page
+<% keyword = 'When' -%>
+<% args.each do |arg| -%>
+    <%= keyword %> I fill in "<%= arg.humanize %>" with "My <%= singular_name %> <%= arg %>"
+<% keyword = 'And' -%>
+<% end -%>
+    And I press "Create"
+<% keyword = 'Then' -%>
+<% args.each do |arg| -%>
+    <%= keyword %> I should see "My <%= singular_name %> <%= arg %>"
+<% keyword = 'And' -%>
+<% end -%>
+
+  Scenario: Delete <%= singular_name %>
+    Given there are 4 <%= plural_name %>
+    When I delete the first <%= singular_name %>
+    Then there should be 3 <%= plural_name %> left
+    
+    | initial | after |
+    | 100     | 99    |
+    | 1       | 0     |

data/generators/feature/templates/steps.erb

@@ -0,0 +1,22 @@
+Given /I am on the new <%= singular_name %> page/ do
+  visits "/<%= plural_name %>/new"
+end
+
+Given /there are (\d+) <%= plural_name %>/ do |n|
+  <%= class_name %>.transaction do
+    <%= class_name %>.destroy_all
+    n.to_i.times do |n|
+      <%= class_name %>.create! :name => "<%= class_name %> #{n}"
+    end
+  end
+end
+
+When /I delete the first <%= singular_name %>/ do
+  visits <%= plural_name %>_url
+  clicks_link "Destroy"
+end
+
+Then /there should be (\d+) <%= plural_name %> left/ do |n|
+  <%= class_name %>.count.should == n.to_i
+  response.should have_tag("table tr", n.to_i + 1) # There is a header row too
+end

data/lib/cucumber.rb

@@ -0,0 +1,32 @@
+$:.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/executor'
+require 'cucumber/step_mother'
+require 'cucumber/formatters'
+require 'cucumber/treetop_parser/feature_parser'
+require 'cucumber/cli'
+
+module Cucumber
+  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(File.dirname(__FILE__) + '/cucumber/languages.yml')
+    end
+  end  
+end

data/lib/cucumber/cli.rb

@@ -0,0 +1,163 @@
+require 'optparse'
+require 'cucumber'
+
+module Cucumber
+  class CLI
+    class << self
+      attr_writer :step_mother, :features
+    
+      def execute
+        @execute_called = true
+        parse(ARGV).execute!(@step_mother, @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 progress html}
+
+    def initialize
+      @paths = []
+    end
+
+    def parse_options!(args)
+      return parse_args_from_profile('default') if args.empty?
+      args.extend(OptionParser::Arguable)
+
+      @options = { :require => nil, :lang => 'en', :format => 'pretty', :dry_run => false }
+      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") 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("-a LANG", "--language LANG", "Specify language for features (Default: #{@options[:lang]})",
+          "Available languages: #{Cucumber.languages.join(", ")}") do |v|
+          @options[:lang] = v
+        end
+        opts.on("-f FORMAT", "--format FORMAT", "How to format features (Default: #{@options[:format]})",
+          "Available formats: #{FORMATS.join(", ")}") do |v|
+          unless FORMATS.index(v) 
+            STDERR.puts "Invalid format: #{v}\n"
+            STDERR.puts opts.help
+            exit 1
+          end
+          @options[:format] = v
+        end
+        opts.on("-p=PROFILE", "--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_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!
+      
+      # Whatever is left after option parsing is the FILE arguments
+      @paths += args
+    end
+    
+    def parse_args_from_profile(profile)
+      require 'yaml'
+      cucumber_yml = YAML::load(IO.read('cucumber.yml'))
+      args_from_yml = cucumber_yml[profile]
+      raise "Expected to find a String, got #{args_from_yml.inspect}. cucumber.yml:\n#{cucumber_yml}" unless String === args_from_yml
+      parse_options!(args_from_yml.split(' '))
+    end
+    
+    def execute!(step_mother, features)
+      Cucumber.load_language(@options[:lang])
+      $executor = Executor.new(formatter(step_mother), step_mother)
+      require_files
+      load_plain_text_features(features)
+      $executor.line = @options[:line].to_i if @options[:line]
+      $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
+      @paths.map do |path|
+        path = path.gsub(/\\/, '/') # In case we're on windows. Globs don't work with backslashes.
+        File.directory?(path) ? Dir["#{path}/**/*.feature"] : path
+      end.flatten.uniq
+    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 formatter(step_mother)
+      case @options[:format]
+      when 'pretty'
+        Formatters::PrettyFormatter.new(STDOUT)
+      when 'progress'
+        Formatters::ProgressFormatter.new(STDOUT)
+      when 'html'
+        Formatters::HtmlFormatter.new(STDOUT, step_mother)
+      end
+    end
+    
+  end
+end
+
+extend Cucumber::StepMethods
+Cucumber::CLI.step_mother = step_mother
+
+extend(Cucumber::Tree)
+Cucumber::CLI.features = features
+
+at_exit do
+  Cucumber::CLI.execute unless Cucumber::CLI.execute_called?
+end