aslakhellesoy-cucumber 0.1.99.3 → 0.1.99.4

data/features/support/env.rb

@@ -1,7 +0,0 @@
-require 'spec/expectations'
-require 'fileutils'
-
-After do
-  FileUtils.rm_rf 'examples/self_test/tmp'
-  FileUtils.mkdir 'examples/self_test/tmp'
-end

data/gem_tasks/deployment.rake

@@ -1,11 +0,0 @@
-desc 'Install the package as a gem, without generating documentation(ri/rdoc)'
-task :install_gem_no_doc => [:clean, :package] do
-  sh "#{'sudo ' unless Hoe::WINDOZE }gem install pkg/*.gem --no-rdoc --no-ri"
-end
-
-namespace :manifest do
-  desc 'Recreate Manifest.txt to include ALL files'
-  task :refresh do
-    `rake check_manifest | patch -p0 > Manifest.txt`
-  end
-end

data/gem_tasks/environment.rake

@@ -1,7 +0,0 @@
-task :ruby_env do
-  RUBY_APP = if RUBY_PLATFORM =~ /java/
-    "jruby"
-  else
-    "ruby"
-  end unless defined? RUBY_APP
-end

data/gem_tasks/features.rake

@@ -1,6 +0,0 @@
-$:.unshift(File.dirname(__FILE__) + '/../lib')
-require 'cucumber/rake/task'
-
-Cucumber::Rake::Task.new do |t|
-  t.cucumber_opts = "--format progress"
-end

data/gem_tasks/fix_cr_lf.rake

@@ -1,10 +0,0 @@
-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) || f =~ /dos/
-    s = IO.read(f)
-    s.gsub!(/\r?\n/, "\n")
-    File.open(f, "w") { |io| io.write(s) }
-  end
-end

data/gem_tasks/flog.rake

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

data/gem_tasks/gemspec.rake

@@ -1,10 +0,0 @@
-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)}
-    puts "1) git commit -a -m \"Release #{Cucumber::VERSION::STRING}\""
-    puts "2) git tag -a \"v#{Cucumber::VERSION::STRING}\" -m \"Release #{Cucumber::VERSION::STRING}\""
-    puts "3) git push --tags"
-    puts "4) Bounce the version in version.rb"
-  end
-end

data/gem_tasks/rspec.rake

@@ -1,35 +0,0 @@
-def unable_to_load
-  STDERR.puts <<-EOS
-To use rspec for testing you must install rspec gem:
-    gem install rspec
-    
-EOS
-  nil
-end
-
-def require_spec
-  require 'spec/expectations'
-rescue LoadError
-  require_spec_with_rubygems
-end
-
-def require_spec_with_rubygems
-  require 'rubygems'
-  require 'spec/expectations'
-rescue LoadError
-  unable_to_load
-end
-
-if require_spec
-  begin
-    require 'spec/rake/spectask'
-  rescue LoadError
-    unable_to_load
-  end
-
-  desc "Run the Cucumber specs"
-  Spec::Rake::SpecTask.new do |t|
-    t.spec_opts = ['--options', "spec/spec.opts"]
-    t.spec_files = FileList['spec/**/*_spec.rb']
-  end
-end

data/gem_tasks/yard.rake

@@ -1,8 +0,0 @@
-begin
-  require 'yard'
-  
-  YARD::Rake::YardocTask.new do |t|
-    t.files   = ['lib/**/*.rb']
-  end
-rescue LoadError => ignore
-end

data/lib/autotest/cucumber.rb

@@ -1,6 +0,0 @@
-require 'autotest'
-require 'autotest/cucumber_mixin'
-
-class Autotest::Cucumber < Autotest
-  include CucumberMixin
-end

data/lib/autotest/cucumber_mixin.rb

@@ -1,124 +0,0 @@
-require 'autotest'
-require 'tempfile'
-require 'yaml'
-require File.dirname(__FILE__) + '/../cucumber'
-
-module Autotest::CucumberMixin
-  def self.included(receiver)
-    receiver::ALL_HOOKS << [:run_features, :ran_features]
-  end
-  
-  attr_accessor :features_to_run
-  
-  def initialize
-    super
-    reset_features
-  end
-  
-  def run
-    hook :initialize
-    reset
-    reset_features
-    add_sigint_handler
-
-    self.last_mtime = Time.now if $f
-
-    loop do # ^c handler
-      begin
-        get_to_green
-        if self.tainted then
-          rerun_all_tests
-          rerun_all_features if all_good
-        else
-          hook :all_good
-        end
-        wait_for_changes
-        # Once tests and features are green, reset features every
-        # time a file is changed to see if anything breaks.
-        reset_features
-      rescue Interrupt
-        break if self.wants_to_quit
-        reset
-        reset_features
-      end
-    end
-    hook :quit
-  end
-  
-  def all_features_good
-    features_to_run == ""
-  end
-  
-  def get_to_green
-    begin
-      super
-      run_features
-      wait_for_changes unless all_features_good
-    end until all_features_good
-  end
-  
-  def rerun_all_features
-    reset_features
-    run_features
-  end
-  
-  def reset_features
-    self.features_to_run = :all
-  end
-    
-  def run_features
-    hook :run_features
-    Tempfile.open('autotest-cucumber') do |dirty_features_file|
-      cmd = self.make_cucumber_cmd(self.features_to_run, dirty_features_file.path)
-      return if cmd.empty?
-      puts cmd unless $q
-      old_sync = $stdout.sync
-      $stdout.sync = true
-      self.results = []
-      line = []
-      begin
-        open("| #{cmd}", "r") do |f|
-          until f.eof? do
-            c = f.getc
-            putc c
-            line << c
-            if c == ?\n then
-              self.results << if RUBY_VERSION >= "1.9" then
-                                line.join
-                              else
-                                line.pack "c*"
-                              end
-              line.clear
-            end
-          end
-        end
-      ensure
-        $stdout.sync = old_sync
-      end
-      self.features_to_run = dirty_features_file.read
-      self.tainted = true unless self.features_to_run == []
-    end
-    hook :ran_features
-  end
-  
-  def make_cucumber_cmd(features_to_run, dirty_features_filename)
-    return '' if features_to_run == ''
-    
-    profiles = YAML.load_file("cucumber.yml").keys rescue []
-    
-    profile ||= "autotest-all" if profiles.include?("autotest-all") and features_to_run == :all
-    profile ||= "autotest"     if profiles.include?("autotest")
-    profile ||= nil
-    
-    if profile
-      args = ["--profile", profile]
-    else
-      args = %w{--format} << (features_to_run == :all ? "progress" : "pretty")
-    end
-    args += %w{--color --format rerun --out} << dirty_features_filename
-    args << (features_to_run == :all ? "features" : features_to_run)
-    args = args.join(' ')
-
-    return "#{Cucumber::RUBY_BINARY} #{Cucumber::BINARY} #{args}"
-  end
-end

data/lib/autotest/cucumber_rails.rb

@@ -1,6 +0,0 @@
-require 'autotest/rails'
-require 'autotest/cucumber_mixin'
-
-class Autotest::CucumberRails < Autotest::Rails
-  include CucumberMixin
-end

data/lib/autotest/cucumber_rails_rspec.rb

@@ -1,6 +0,0 @@
-require 'autotest/cucumber_mixin'
-require 'autotest/rails_rspec'
-
-class Autotest::CucumberRailsRspec < Autotest::RailsRspec
-  include CucumberMixin
-end

data/lib/autotest/cucumber_rspec.rb

@@ -1,6 +0,0 @@
-require 'autotest/cucumber_mixin'
-require 'autotest/rspec'
-
-class Autotest::CucumberRspec < Autotest::Rspec
-  include CucumberMixin
-end

data/lib/autotest/discover.rb

@@ -1,9 +0,0 @@
-Autotest.add_discovery do
-  if File.directory?('features')
-    if ENV['AUTOFEATURE'] =~ /true/i
-      "cucumber"
-    else
-      puts "(Not running features.  To run features in autotest, set AUTOFEATURE=true.)"
-    end
-  end
-end

data/lib/cucumber/ast/comment.rb

@@ -1,26 +0,0 @@
-module Cucumber
-  module Ast
-    # Holds the value of a comment parsed from a feature file:
-    #
-    #   # Lorem ipsum
-    #   # dolor sit amet
-    #
-    # This gets parsed into a Comment with value <tt>"# Lorem ipsum\n# dolor sit amet\n"</tt>
-    #
-    class Comment
-      def initialize(value)
-        @value = value
-      end
-
-      def accept(visitor)
-        @value.split("\n").each do |line|
-          visitor.visit_comment_line(line.strip)
-        end
-      end
-      
-      def to_sexp
-        (@value.nil? || @value == '') ? nil : [:comment, @value]
-      end
-    end
-  end
-end

data/lib/cucumber/ast/examples.rb

@@ -1,22 +0,0 @@
-module Cucumber
-  module Ast
-    class Examples
-      def initialize(line, keyword, name, outline_table)
-        @keyword, @name, @outline_table = keyword, name, outline_table
-      end
-
-      def accept(visitor)
-        visitor.visit_examples_name(@keyword, @name)
-        @outline_table.accept(visitor, nil)
-      end
-
-      def at_lines?(lines)
-        lines.empty? || lines.index(@line) || @outline_table.at_lines?(lines)
-      end
-
-      def to_sexp
-        [:examples, @keyword, @name, @outline_table.to_sexp]
-      end
-    end
-  end
-end

data/lib/cucumber/ast/feature.rb

@@ -1,60 +0,0 @@
-module Cucumber
-  module Ast
-    # Represents the root node of a parsed feature.
-    class Feature
-      attr_accessor :file
-      attr_writer :features, :lines
-
-      def initialize(comment, tags, name, feature_elements)
-        @comment, @tags, @name, @feature_elements = comment, tags, name, feature_elements
-        feature_elements.each{|feature_element| feature_element.feature = self}
-        @lines = []
-      end
-
-      def tagged_with?(tag_names, check_elements=true)
-        @tags.among?(tag_names) || 
-        (check_elements && @feature_elements.detect{|e| e.tagged_with?(tag_names)})
-      end
-      
-      def matches_scenario_names?(scenario_names)
-        @feature_elements.detect{|e| e.matches_scenario_names?(scenario_names)}
-      end
-
-      def accept(visitor)
-        visitor.current_feature_lines = @lines
-        visitor.visit_comment(@comment)
-        visitor.visit_tags(@tags)
-        visitor.visit_feature_name(@name)
-        @feature_elements.each do |feature_element|
-          visitor.visit_feature_element(feature_element) if @features.visit?(feature_element, @lines)
-        end
-      end
-
-      def scenario_executed(scenario)
-        @features.scenario_executed(scenario) if @features
-      end
-
-      def step_executed(step)
-        @features.step_executed(step) if @features
-      end
-
-      def backtrace_line(step_name, line)
-        "#{file_line(line)}:in `#{step_name}'"
-      end
-
-      def file_line(line)
-        "#{@file}:#{line}"
-      end
-
-      def to_sexp
-        sexp = [:feature, @name]
-        comment = @comment.to_sexp
-        sexp += [comment] if comment
-        tags = @tags.to_sexp
-        sexp += tags if tags.any?
-        sexp += @feature_elements.map{|e| e.to_sexp}
-        sexp
-      end
-    end
-  end
-end

data/lib/cucumber/ast/features.rb

@@ -1,39 +0,0 @@
-module Cucumber
-  module Ast
-    class Features
-      attr_reader :steps, :scenarios
-
-      def initialize(filter)
-        @filter = filter
-
-        @features = []
-        @scenarios = []
-        @steps = Hash.new{|steps, status| steps[status] = []}
-      end
-
-      def add_feature(feature)
-        feature.features = self
-        @features << feature
-      end
-
-      def visit?(node, lines)
-        @filter.matched?(node) &&
-        (lines.empty? ? true : node.at_lines?(lines))
-      end
-
-      def scenario_executed(scenario)
-        @scenarios << scenario
-      end
-      
-      def step_executed(step)
-        @steps[step.status] << step
-      end
-
-      def accept(visitor)
-        @features.each do |feature|
-          visitor.visit_feature(feature) if visit?(feature, [])
-        end
-      end
-    end
-  end
-end

data/lib/cucumber/ast/filter.rb

@@ -1,22 +0,0 @@
-module Cucumber
-  module Ast
-    class Filter
-      def initialize(options)
-        @options = options
-      end
-      
-      def matched?(node)
-        matched_by_tags?(node) &&
-        matched_by_scenario_names?(node)
-      end
-      
-      def matched_by_tags?(node)
-        @options[:tags].empty? || node.tagged_with?(@options[:tags])
-      end
-
-      def matched_by_scenario_names?(node)
-        @options[:scenario_names].empty? || node.matches_scenario_names?(@options[:scenario_names])
-      end
-    end
-  end
-end

data/lib/cucumber/ast/outline_table.rb

@@ -1,49 +0,0 @@
-module Cucumber
-  module Ast
-    class OutlineTable < Table
-      def initialize(raw, scenario_outline)
-        super(raw)
-        @scenario_outline = scenario_outline
-        @cells_class = ExampleCells
-      end
-
-      def accept(visitor, status)
-        rows.each_with_index do |row, n|
-          should_visit = n == 0 || 
-            row.at_lines?(visitor.current_feature_lines) ||
-            @scenario_outline.at_header_or_step_lines?(visitor.current_feature_lines)
-
-          if should_visit
-            visitor.visit_table_row(row, status)
-          end
-        end
-        nil
-      end
-
-      def execute_row(cells, visitor, &proc)
-        @scenario_outline.execute_row(cells, visitor, &proc)
-      end
-
-      class ExampleCells < Cells
-        def accept(visitor, status)
-          if header?
-            @cells.each do |cell|
-              visitor.visit_table_cell(cell, :thead)
-            end
-            nil
-          else
-            exception = @table.execute_row(self, visitor) do |cell, status|
-              visitor.visit_table_cell(cell, status)
-            end
-          end
-        end
-
-        private
-
-        def header?
-          index == 0
-        end
-      end
-    end
-  end
-end

data/lib/cucumber/ast/py_string.rb

@@ -1,52 +0,0 @@
-module Cucumber
-  module Ast
-    # Represents an inline argument in a step. Example:
-    #
-    #   Given the message
-    #     """
-    #     I like
-    #     Cucumber sandwich
-    #     """
-    #
-    # The text between the pair of <tt>"""</tt> is stored inside a PyString,
-    # which is yielded to the StepDefinition block as the last argument.
-    #
-    # The StepDefinition can then access the String via the #to_s method. In the
-    # example above, that would return: <tt>"I like\nCucumber sandwich"</tt>
-    #
-    # Note how the indentation from the source is stripped away.
-    #
-    class PyString
-      def initialize(start_line, end_line, string, quotes_indent)
-        @start_line, @end_line = start_line, end_line
-        @string, @quotes_indent = string, quotes_indent
-      end
-
-      def to_s
-        @string.indent(-@quotes_indent)
-      end
-
-      def at_lines?(lines)
-        lines.detect{|l| l >= @start_line && l <= @end_line}
-      end
-
-      def accept(visitor, status)
-        visitor.visit_py_string(to_s, status)
-      end
-      
-      def arguments_replaced(arguments) #:nodoc:
-        string = @string
-        arguments.each do |name, value|
-          string = string.gsub(name, value)
-        end
-        PyString.new(@start_line, @end_line, string, @quotes_indent)
-      end
-      
-      # For testing only
-      def to_sexp #:nodoc:
-        [:py_string, to_s]
-      end
-                
-    end
-  end
-end

data/lib/cucumber/ast/scenario.rb

@@ -1,95 +0,0 @@
-module Cucumber
-  module Ast
-    class Scenario
-      attr_writer :feature
-      
-      def initialize(comment, tags, line, keyword, name, steps)
-        @comment, @tags, @line, @keyword, @name = comment, tags, line, keyword, name
-        steps.each {|step| step.scenario = self}
-        @steps = steps
-      end
-
-      def status
-        @steps.map{|step| step.status}
-      end
-
-      def tagged_with?(tag_names)
-        @tags.among?(tag_names) || @feature.tagged_with?(tag_names, false)
-      end
-
-      def matches_scenario_names?(scenario_names)
-        scenario_names.detect{|name| @name == name}
-      end
-
-      def accept(visitor)
-        visitor.visit_comment(@comment)
-        visitor.visit_tags(@tags)
-        visitor.visit_scenario_name(@keyword, @name, file_line(@line), source_indent(text_length))
-        visitor.world(self) do |world|
-          previous = :passed
-          @steps.each do |step|
-            step.previous = previous
-            step.world    = world
-            visitor.visit_step(step)
-            previous = step.status
-          end
-        end
-        @feature.scenario_executed(self) if @feature && !@executed
-        @executed = true
-      end
-
-      def source_indent(text_length)
-        max_line_length - text_length
-      end
-
-      def max_line_length
-        lengths = (@steps + [self]).map{|e| e.text_length}
-        lengths.max
-      end
-
-      def text_length
-        @keyword.jlength + @name.jlength
-      end
-
-      def at_lines?(lines)
-        at_header_or_step_lines?(lines)
-      end
-
-      def at_header_or_step_lines?(lines)
-        lines.empty? || lines.index(@line) || @steps.detect {|step| step.at_lines?(lines)} || @tags.at_lines?(lines)
-      end
-
-      def undefined?
-        @steps.empty?
-      end
-
-      def step_executed(step)
-        @feature.step_executed(step) if @feature
-      end
-
-      def backtrace_line(name = "#{@keyword} #{@name}", line = @line)
-        @feature.backtrace_line(name, line) if @feature
-      end
-
-      def file_line(line = @line)
-        @feature.file_line(line) if @feature
-      end
-
-      def previous_step(step)
-        i = @steps.index(step)
-        @steps[i-1]
-      end
-
-      def to_sexp
-        sexp = [:scenario, @line, @keyword, @name]
-        comment = @comment.to_sexp
-        sexp += [comment] if comment
-        tags = @tags.to_sexp
-        sexp += tags if tags.any?
-        steps = @steps.map{|step| step.to_sexp}
-        sexp += steps if steps.any?
-        sexp
-      end
-    end
-  end
-end