elight-cucumber 0.1.9

data/lib/cucumber.rb

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

data/lib/cucumber/cli.rb

@@ -0,0 +1,191 @@
+require 'optparse'
+require 'cucumber'
+
+module Cucumber
+  class CLI
+    class << self
+      attr_writer :step_mother, :executor, :features
+    
+      def execute
+        @execute_called = true
+        parse(ARGV).execute!(@step_mother, @executor, @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 profile progress html}
+
+    def initialize
+      @paths = []
+      @options = { 
+        :require => nil, 
+        :lang    => 'en', 
+        :format  => 'pretty', 
+        :dry_run => false, 
+        :source  => true,
+        :out     => STDOUT,
+        :excludes => []
+      }
+    end
+
+    def parse_options!(args)
+      return parse_args_from_profile('default') if args.empty?
+      args.extend(OptionParser::Arguable)
+
+      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(", ")}",
+          "Look at #{Cucumber::LANGUAGE_FILE} for keywords") 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("--exclude=PATTERN", "Don't run features matching a pattern") do |v|
+          @options[:excludes] << 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("-n", "--no-source", "Don't show the file and line of the step definition with the steps.") do
+          @options[:source] = false
+        end
+        opts.on("-o", "--out=FILE", "Write output to a file instead of STDOUT.") do |v|
+          @options[:out] = File.open(v, 'w')
+        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)
+      return unless File.exist?('cucumber.yml')
+      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, executor, features)
+      Cucumber.load_language(@options[:lang])
+      executor.formatter = formatter(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
+      potential_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
+      
+      @options[:excludes].each do |exclude|
+        potential_feature_files.reject! do |path|
+          path =~ /#{Regexp.escape(exclude)}/
+        end
+      end
+      
+      potential_feature_files
+    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(@options[:out], step_mother, @options)
+      when 'progress'
+        Formatters::ProgressFormatter.new(@options[:out])
+       when 'profile'
+        Formatters::ProfileFormatter.new(@options[:out], step_mother)
+      when 'html'
+        Formatters::HtmlFormatter.new(@options[:out], step_mother)
+      else
+        raise "Unknown formatter: #{@options[:format]}"
+      end
+    end
+    
+  end
+end
+
+extend Cucumber::StepMethods
+Cucumber::CLI.step_mother = step_mother
+Cucumber::CLI.executor = executor
+
+extend Cucumber::Tree
+Cucumber::CLI.features = features

data/lib/cucumber/core_ext/proc.rb

@@ -0,0 +1,55 @@
+module Cucumber
+  class ArityMismatchError < StandardError
+  end
+
+  module CoreExt
+    # Proc extension that allows a proc to be called in the context of any object.
+    # Also makes it possible to tack a name onto a Proc.
+    module CallIn
+      attr_accessor :name
+      
+      def call_in(obj, *args)
+        obj.extend(mod)
+        a = arity == -1 ? 0 : arity
+        if self != StepMother::PENDING && args.length != a
+          # We have to manually raise when the block has arity -1 (no pipes)
+          raise ArityMismatchError.new("expected #{arity == -1 ? 0 : arity} block argument(s), got #{args.length}")
+        else
+          obj.__send__(meth, *args)
+        end
+      end
+
+      def arity2
+        arity == -1 ? 0 : arity
+      end
+
+      def to_backtrace_line
+        "#{file_colon_line}:in `#{name}'"
+      end
+      
+      def to_comment_line
+        "# #{file_colon_line}"
+      end
+      
+      def file_colon_line
+        path, line = *to_s.match(/[\d\w]+@(.*):(.*)>/)[1..2]
+        path = File.expand_path(path)
+        pwd = Dir.pwd
+        path = path[pwd.length+1..-1]        
+        "#{path}:#{line}"
+      end
+
+      def meth
+        @meth ||= "__cucumber_#{object_id}"
+      end
+
+      def mod
+        p = self
+        m = meth
+        @mod ||= Module.new do
+          define_method(m, &p)
+        end
+      end
+    end 
+  end
+end

data/lib/cucumber/core_ext/string.rb

@@ -0,0 +1,22 @@
+class String
+  def gzub(regexp, format=nil, &proc)
+    md = match(regexp)
+    raise "#{self.inspect} doesn't match #{regexp.inspect}" if md.nil?
+    
+    s = dup
+    pos = 0
+    md.captures.each_with_index do |m, n|
+      replacement = if block_given?
+        proc.call(m)
+      else
+        format % m
+      end
+      
+      if md.offset(n+1)[0]
+        s[md.offset(n+1)[0] + pos, m.length] = replacement
+        pos += replacement.length - m.length
+      end
+    end
+    s
+  end
+end

data/lib/cucumber/executor.rb

@@ -0,0 +1,143 @@
+require 'cucumber/core_ext/proc'
+
+module Cucumber
+  class Executor
+    attr_reader :failed
+    attr_accessor :formatter
+    
+    def line=(line)
+      @line = line
+    end
+
+    def initialize(step_mother)
+      @world_proc = lambda do 
+        Object.new
+      end
+      @before_scenario_procs = []
+      @after_scenario_procs = []
+      @after_step_procs = []
+      @step_mother = step_mother
+    end
+    
+    def register_world_proc(&proc)
+      @world_proc = proc
+    end
+
+    def register_before_scenario_proc(&proc)
+      proc.extend(CoreExt::CallIn)
+      @before_scenario_procs << proc
+    end
+
+    def register_after_scenario_proc(&proc)
+      proc.extend(CoreExt::CallIn)
+      @after_scenario_procs << proc
+    end
+
+    def register_after_step_proc(&proc)
+      proc.extend(CoreExt::CallIn)
+      @after_step_procs << proc
+    end
+
+    def visit_features(features)
+      raise "Line number can only be specified when there is 1 feature. There were #{features.length}." if @line && features.length != 1
+      formatter.visit_features(features) if formatter.respond_to?(:visit_features)
+      features.accept(self)
+      formatter.dump
+    end
+
+    def visit_feature(feature)
+      formatter.visit_feature(feature) if formatter.respond_to?(:visit_feature)
+      feature.accept(self)
+    end
+
+    def visit_header(header)
+      formatter.header_executing(header) if formatter.respond_to?(:header_executing)
+    end
+
+    def visit_row_scenario(scenario)
+      visit_scenario(scenario)
+    end
+
+    def visit_regular_scenario(scenario)
+      visit_scenario(scenario)
+    end
+
+    def visit_scenario(scenario)
+      if accept?(scenario)
+        @error = nil
+        @pending = nil
+
+        @world = @world_proc.call
+        @world.extend(Spec::Matchers) if defined?(Spec::Matchers)
+        define_step_call_methods(@world)
+
+        formatter.scenario_executing(scenario) if formatter.respond_to?(:scenario_executing)
+        @before_scenario_procs.each{|p| p.call_in(@world, *[])}
+        scenario.accept(self)
+        @after_scenario_procs.each{|p| p.call_in(@world, *[])}
+        formatter.scenario_executed(scenario) if formatter.respond_to?(:scenario_executed)
+      end
+    end
+    
+    def accept?(scenario)
+      @line.nil? || scenario.at_line?(@line)
+    end
+
+    def visit_row_step(step)
+      visit_step(step)
+    end
+
+    def visit_regular_step(step)
+      visit_step(step)
+    end
+
+    def visit_step(step)
+      unless @pending || @error
+        begin
+          regexp, args, proc = step.regexp_args_proc(@step_mother)
+          formatter.step_executing(step, regexp, args) if formatter.respond_to?(:step_executing)
+          step.execute_in(@world, regexp, args, proc)
+          @after_step_procs.each{|p| p.call_in(@world, *[])}
+          formatter.step_passed(step, regexp, args)
+        rescue Pending
+          record_pending_step(step, regexp, args)
+        rescue => e
+          @failed = true
+          @error = step.error = e
+          formatter.step_failed(step, regexp, args)
+        end
+      else
+        begin
+          regexp, args, proc = step.regexp_args_proc(@step_mother)
+          step.execute_in(@world, regexp, args, proc)
+          formatter.step_skipped(step, regexp, args)
+        rescue Pending
+          record_pending_step(step, regexp, args)
+        rescue Exception
+          formatter.step_skipped(step, regexp, args)
+        end
+      end
+    end
+    
+    def record_pending_step(step, regexp, args)
+      @pending = true
+      formatter.step_pending(step, regexp, args)
+    end
+
+    def define_step_call_methods(world)
+      world.instance_variable_set('@__executor', self)
+      world.instance_eval do
+        class << self
+          def run_step(name)
+            _, args, proc = @__executor.instance_variable_get(:@step_mother).regexp_args_proc(name)
+            proc.call_in(self, *args)
+          end
+
+          %w{given when then and but}.each do |keyword|
+            alias_method Cucumber.language[keyword], :run_step
+          end
+        end
+      end
+    end
+  end
+end