mobiusloop 0.1.2

data/lib/autotest/cucumber.rb

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

data/lib/autotest/cucumber_mixin.rb

@@ -0,0 +1,135 @@
+require 'autotest'
+require 'tempfile'
+require 'cucumber'
+require 'cucumber/cli/profile_loader'
+
+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 or break
+            if RUBY_VERSION >= "1.9" then
+              print c
+            else
+              putc c
+            end
+            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.strip
+      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 == ''
+
+    profile_loader = Cucumber::Cli::ProfileLoader.new
+
+    profile ||= "autotest-all" if profile_loader.has_profile?("autotest-all") && features_to_run == :all
+    profile ||= "autotest"     if profile_loader.has_profile?("autotest")
+    profile ||= nil
+
+    if profile
+      args = ["--profile", profile]
+    else
+      args = %w{--format} << (features_to_run == :all ? "progress" : "pretty")
+    end
+    # No --color option as some IDEs (Netbeans) don't output them very well (1 failed step)
+    args += %w{--format rerun --out} << dirty_features_filename
+    args << (features_to_run == :all ? "" : features_to_run)
+
+    # Unless I do this, all the steps turn up undefined during the rerun...
+    unless features_to_run == :all
+      args << 'features/step_definitions' << 'features/support'
+    end
+
+    args = args.join(' ')
+
+    return "#{Cucumber::RUBY_BINARY} #{Cucumber::BINARY} #{args}"
+  end
+end

data/lib/autotest/cucumber_rails.rb

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

data/lib/autotest/cucumber_rails_rspec.rb

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

data/lib/autotest/cucumber_rails_rspec2.rb

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

data/lib/autotest/cucumber_rspec.rb

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

data/lib/autotest/cucumber_rspec2.rb

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

data/lib/autotest/discover.rb

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

data/lib/cucumber.rb

@@ -0,0 +1,37 @@
+require 'yaml'
+require 'cucumber/encoding'
+require 'cucumber/platform'
+require 'cucumber/runtime'
+require 'cucumber/cli/main'
+require 'cucumber/step_definitions'
+require 'cucumber/term/ansicolor'
+
+module Cucumber
+  class << self
+    attr_accessor :wants_to_quit
+
+    def logger
+      return @log if @log
+      @log = Logger.new(STDOUT)
+      @log.level = Logger::INFO
+      @log
+    end
+
+    def logger=(logger)
+      @log = logger
+    end
+
+    if Cucumber::RUBY_1_9
+      # Backported from Ruby 2.0 to 1.9
+      def Hash(other)
+        return {} if other.nil? || other == []
+        raise TypeError, "can't convert #{other.class} into Hash" unless other.respond_to?(:to_hash)
+        other.to_hash
+      end
+    else
+      def Hash(other)
+        Kernel::Hash(other)
+      end
+    end
+  end
+end

data/lib/cucumber/ast.rb

@@ -0,0 +1,13 @@
+require 'cucumber/multiline_argument'
+
+module Cucumber
+  module Ast
+    def self.const_missing(const_name)
+      if const_name == :Table
+        warn "`Cucumber::Ast::Table` has been deprecated. Use `Cucumber::MultilineArgument::DataTable` instead."
+        return Cucumber::MultilineArgument::DataTable
+      end
+      raise "`Cucumber::Ast` no longer exists. These classes have moved into the `Cucumber::Core::Ast` namespace, but may not have the same API."
+    end
+  end
+end

data/lib/cucumber/cli/configuration.rb

@@ -0,0 +1,146 @@
+require 'logger'
+require 'cucumber/cli/options'
+require 'cucumber/cli/rerun_file'
+require 'cucumber/constantize'
+require 'cucumber/core/gherkin/tag_expression'
+
+module Cucumber
+  module Cli
+    class YmlLoadError < StandardError; end
+    class ProfilesNotDefinedError < YmlLoadError; end
+    class ProfileNotFound < StandardError; end
+
+    class Configuration
+      include Constantize
+
+      attr_reader :out_stream
+
+      def initialize(out_stream = STDOUT, error_stream = STDERR)
+        @out_stream   = out_stream
+        @error_stream = error_stream
+        @options = Options.new(@out_stream, @error_stream, :default_profile => 'default')
+      end
+
+      def parse!(args)
+        @args = args
+        @options.parse!(args)
+        arrange_formats
+        raise("You can't use both --strict and --wip") if strict? && wip?
+        # todo: remove
+        @options[:tag_expression] = Cucumber::Core::Gherkin::TagExpression.new(@options[:tag_expressions])
+        set_environment_variables
+      end
+
+      def verbose?
+        @options[:verbose]
+      end
+
+      def randomize?
+        @options[:order] == 'random'
+      end
+
+      def seed
+        Integer(@options[:seed] || rand(0xFFFF))
+      end
+
+      def strict?
+        @options[:strict]
+      end
+
+      def wip?
+        @options[:wip]
+      end
+
+      def guess?
+        @options[:guess]
+      end
+
+      def dry_run?
+        @options[:dry_run]
+      end
+
+      def expand?
+        @options[:expand]
+      end
+
+      def fail_fast?
+        !!@options[:fail_fast]
+      end
+
+      def retry_attempts
+        @options[:retry]
+      end
+
+      def snippet_type
+        @options[:snippet_type] || :regexp
+      end
+
+      def log
+        logger = Logger.new(@out_stream)
+        logger.formatter = LogFormatter.new
+        logger.level = Logger::INFO
+        logger.level = Logger::DEBUG if self.verbose?
+        logger
+      end
+
+      # todo: remove
+      def tag_expression
+        Cucumber::Core::Gherkin::TagExpression.new(@options[:tag_expressions])
+      end
+
+      def tag_limits
+        tag_expression.limits.to_hash
+      end
+
+      def tag_expressions
+        @options[:tag_expressions]
+      end
+
+      def name_regexps
+        @options[:name_regexps]
+      end
+
+      def filters
+        @options.filters
+      end
+
+      def formats
+        @options[:formats]
+      end
+
+      def options
+        warn("Deprecated: Configuration#options will be removed from the next release of Cucumber. Please use the configuration object directly instead.")
+        @options
+      end
+
+      def paths
+        @options[:paths]
+      end
+
+      def to_hash
+        Cucumber::Hash(@options).merge(out_stream: @out_stream, error_stream: @error_stream)
+      end
+
+      private
+
+      class LogFormatter < ::Logger::Formatter
+        def call(severity, time, progname, msg)
+          msg
+        end
+      end
+
+      def set_environment_variables
+        @options[:env_vars].each do |var, value|
+          ENV[var] = value
+        end
+      end
+
+      def arrange_formats
+        @options[:formats] << ['pretty', @out_stream] if @options[:formats].empty?
+        @options[:formats] = @options[:formats].sort_by{|f| f[1] == @out_stream ? -1 : 1}
+        @options[:formats].uniq!
+        @options.check_formatter_stream_conflicts()
+      end
+    end
+  end
+end

data/lib/cucumber/cli/main.rb

@@ -0,0 +1,99 @@
+require 'optparse'
+require 'cucumber'
+require 'logger'
+require 'cucumber/cli/configuration'
+
+module Cucumber
+  module Cli
+    class Main
+      class << self
+        def execute(args)
+          new(args).execute!
+        end
+      end
+
+      def initialize(args, _=nil, out=STDOUT, err=STDERR, kernel=Kernel)
+        @args   = args
+        @out    = out
+        @err    = err
+        @kernel = kernel
+      end
+
+      def execute!(existing_runtime = nil)
+        trap_interrupt
+
+        runtime = if existing_runtime
+          existing_runtime.configure(configuration)
+          existing_runtime
+        else
+          Runtime.new(configuration)
+        end
+
+        runtime.run!
+        if Cucumber.wants_to_quit
+          exit_unable_to_finish
+        else
+          if runtime.failure?
+            exit_tests_failed
+          else
+            exit_ok
+          end
+        end
+      rescue SystemExit => e
+        @kernel.exit(e.status)
+      rescue FileNotFoundException => e
+        @err.puts(e.message)
+        @err.puts("Couldn't open #{e.path}")
+        exit_unable_to_finish
+      rescue FeatureFolderNotFoundException => e
+        @err.puts(e.message + ". You can use `mobiusloop --init` to get started.")
+        exit_unable_to_finish
+      rescue ProfilesNotDefinedError, YmlLoadError, ProfileNotFound => e
+        @err.puts(e.message)
+        exit_unable_to_finish
+      rescue Errno::EACCES, Errno::ENOENT => e
+        @err.puts("#{e.message} (#{e.class})")
+        exit_unable_to_finish
+      rescue Exception => e
+        @err.puts("#{e.message} (#{e.class})")
+        @err.puts(e.backtrace.join("\n"))
+        exit_unable_to_finish
+      end
+
+      def configuration
+        @configuration ||= Configuration.new(@out, @err).tap do |configuration|
+          configuration.parse!(@args)
+          Cucumber.logger = configuration.log
+        end
+      end
+
+      private
+
+
+      def exit_ok
+        @kernel.exit 0
+      end
+
+      def exit_tests_failed
+        @kernel.exit 1
+      end
+
+      def exit_unable_to_finish
+        @kernel.exit 2
+      end
+
+      # stops the program immediately, without running at_exit blocks
+      def exit_unable_to_finish!
+        @kernel.exit! 2
+      end
+
+      def trap_interrupt
+        trap('INT') do
+          exit_unable_to_finish! if Cucumber.wants_to_quit
+          Cucumber.wants_to_quit = true
+          STDERR.puts "\nExiting... Interrupt again to exit immediately."
+        end
+      end
+    end
+  end
+end