nitrous 1.0.3

data/lib/nitrous/progress_bar.rb

@@ -0,0 +1,82 @@
+require 'curses'
+
+module Kernel
+  def puts(*args)
+    $stdout.puts(*args)
+  end
+end
+
+module Nitrous
+  class ProgressBarAwareStandardOut
+    def initialize(stdout, progress_bar)
+      @stdout, @progress_bar = stdout, progress_bar
+    end
+
+    def write(object)
+      @progress_bar.delete_bar
+      @stdout.write(object)
+      @progress_bar.redraw_bar
+    end
+    
+    def print(*args)
+      args.each do |arg|
+        write(arg)
+      end
+    end
+
+    def puts(*args)
+      args.each do |arg|
+        write("#{arg}\n")
+      end
+    end
+
+    def direct_write(object)
+      @stdout.write(object)
+    end
+  end
+
+  class ProgressBar
+    RED   = 101
+    GREEN = 102
+
+    attr_accessor :color, :text
+
+    def initialize(steps)
+      @total_steps = steps
+      @step = 0
+      @color = GREEN
+      Curses.init_screen
+      @dimensions = [Curses.stdscr.maxx, Curses.stdscr.maxy]
+      Curses.close_screen
+      $stdout.puts ""
+      $stdout = ProgressBarAwareStandardOut.new($stdout, self)
+      @text = ""
+    end
+
+    def step
+      @step += 1
+      draw
+    end
+
+    def draw_bar(color, width)
+      content = @text[0..[width, @text.length].min] + " " * [width - @text.length, 0].max
+      $stdout.direct_write("\e[#{color}m#{content}\e[0m")
+      $stdout.direct_write(@text[(width + 1)..-1]) if @text.length > width
+      $stdout.direct_write("\n")
+    end
+
+    def delete_bar
+      $stdout.direct_write("\e[1F\e[0K")
+    end
+
+    def draw
+      delete_bar
+      redraw_bar
+    end
+
+    def redraw_bar
+      draw_bar(@color, (@dimensions[0].to_f/@total_steps)*@step)
+      STDOUT.flush
+    end
+  end
+end

data/lib/nitrous/rails_test.rb

@@ -0,0 +1,77 @@
+require 'rails_ext'
+module Nitrous
+  class RailsTest < Nitrous::Test
+    def created(type)
+      lookup(type, ActiveRecord::Base.saved_objects)
+    end
+
+    def assert_created!(type)
+      instance = created(type)
+      fail("Should have created a #{type}.#{invalid(type) ? " Errors: #{invalid(type).errors.full_messages.to_sentence}" : ''}") unless instance
+      yield(instance) if block_given?
+      instance
+    end
+
+    def assert_not_created!(type)
+      instance = created(type).reload rescue nil
+      fail("Should not have created a #{type}. Instance: #{instance.inspect}") if instance
+      yield if block_given?
+    end
+
+    def assert_email_sent!(count=1, &block)
+      assert_equal! @emails + count, ActionMailer::Base.deliveries.size
+      block.call(*ActionMailer::Base.deliveries[-count..-1]) if block_given?
+    ensure
+      @emails = ActionMailer::Base.deliveries.size
+    end
+
+    def assert_no_email_sent!(&block)
+      assert_equal! @emails, ActionMailer::Base.deliveries.size
+      block.call if block_given?
+    ensure
+      @emails = ActionMailer::Base.deliveries.size
+    end
+
+    def invalid(type)
+      lookup(type, ActiveRecord::Base.invalid_objects)
+    end
+
+    def destroyed(type)
+      lookup(type, ActiveRecord::Base.destroyed_objects)
+    end
+
+    def assert_destroyed!(type)
+      instance = destroyed(type)
+      fail("Should have destroyed a #{type}.") unless instance
+      yield(instance) if block_given?
+      instance
+    end
+
+    private
+      def lookup(type, list)
+        (list[type] && list[type].last) || list[type.to_s.singularize.to_sym]
+      end
+
+      def reset_record_tracking
+        if defined?(ActiveRecord)
+          ActiveRecord::Base.saved_objects = {}
+          ActiveRecord::Base.invalid_objects = {}
+          ActiveRecord::Base.destroyed_objects = {}
+        end
+        @emails = ActionMailer::Base.deliveries.size
+      end
+
+      def nitrous_setup
+        super
+        reset_record_tracking
+      end
+
+      def nitrous_teardown
+        if defined?(ActiveRecord)
+          ActiveRecord::Base.send(:subclasses).each do |klass|
+            klass.delete_all rescue nil
+          end
+        end
+      end
+  end
+end

data/lib/nitrous/server.rb

@@ -0,0 +1,4 @@
+PID_FILE = File.expand_path(File.join(RAILS_ROOT, 'tmp/pids/nitrous_server.pid'))
+if File.exists?(PID_FILE) && !`ps ax | grep "\b#{File.read(PID_FILE)}\b"`.empty?
+  `ruby #{File.join(File.dirname(__FILE__), 'daemon_controller.rb')} start #{File.expand_path(RAILS_ROOT)}`
+end

data/lib/nitrous/test.rb

@@ -0,0 +1,121 @@
+require File.dirname(__FILE__) + '/../core_ext'
+require 'nitrous/assertions'
+require 'nitrous/test_block'
+require 'nitrous/test_context'
+require 'nitrous/test_result'
+module Nitrous
+  class Test
+    include Assertions
+    
+    def self.callbacks
+      @@callbacks ||= {:suite_setup => [], :suite_teardown => [], :setup => [], :teardown => []}
+    end
+    
+    def callbacks
+      self.class.callbacks
+    end
+    
+    def self.register_callback(type, &callback)
+      callbacks[type] << callback
+    end
+    
+    def register_callback(type, &callback)
+      self.class.register_callback(type, callback)
+    end
+    
+    def self.tests
+      @tests ||= []
+    end
+    
+    def self.test_classes
+      @test_classes ||= []
+    end
+
+    def self.test(name=nil, &block)
+      self.tests << TestBlock.new(name, block) unless @single_test
+    end
+    
+    def self.stest(name=nil, &block)
+      @tests = [TestBlock.new(name, block)]
+      @single_test = true;
+    end
+
+    def self.ztest(name=nil, &block)
+      self.tests << TestBlock.new(name, block, true) unless @single_test
+    end
+    
+    def self.exclude(klass)
+      @test_classes.delete(klass)
+    end
+
+    def self.inherited(subclass)
+      class << subclass
+        def inherited(subclass)
+          Nitrous::Test.exclude(self)
+          Nitrous::Test.inherited(subclass)
+        end
+      end
+      if !@test_classes
+        @test_classes = []
+        at_exit do
+          callbacks[:suite_setup].each(&:call)
+          context = TestContext.create(@test_classes.sum {|klass| klass.tests.size})
+          @test_classes.each do |klass|
+            klass.run(context)
+          end
+          context.finish
+          callbacks[:suite_teardown].each(&:call)
+          exit(context.exit_status)
+        end
+      end
+      @test_classes << subclass
+    end
+
+    def self.run(context=TestContext.new)
+      self.new(context).run
+    end
+
+    def initialize(context)
+      @context = context
+      @test_results = []
+    end
+    
+    def self.setup; end
+    def self.teardown; end
+    def nitrous_setup; end
+    def nitrous_teardown; end
+    def setup; end
+    def teardown; end
+
+    def collect_errors
+      yield
+    rescue Exception
+      @test_results.last.errors << $!
+      @context.failed($!)
+    end
+
+    def running(test)
+      @current_test = test
+      @test_results << TestResult.new(test)
+    end
+
+    def run
+      puts self.class.name
+      self.class.setup
+      self.class.tests.each do |test_block|
+        running(test_block)
+        nitrous_setup
+        collect_errors do
+          callbacks[:setup].each(&:call)
+          setup
+          test_block.run(self)
+          teardown
+          callbacks[:teardown].each(&:call)
+        end
+        nitrous_teardown
+        @context.ran_test(test_block, @test_results.last)
+      end
+      self.class.teardown
+    end
+  end
+end

data/lib/nitrous/test_block.rb

@@ -0,0 +1,43 @@
+module Nitrous
+  class TestBlock
+    def initialize(name, block, skip=false)
+      @name, @block, @skip = name, block, skip
+    end
+
+    def run(test)
+      test.collect_errors do
+        test.instance_eval(&@block) unless self.skip?
+      end
+    end
+    
+    def filename
+      parse_location
+      @filename
+    end
+    
+    def line
+      parse_location
+      @line
+    end
+    
+    def skip?
+      @skip
+    end
+
+    def to_s
+      @name || first_line
+    end
+    
+    def first_line
+      "[ #{File.readlines(filename)[line].strip} ]"
+    end
+    
+    private
+      def parse_location
+        return if @filename && @line
+        @block.inspect =~ /#<Proc:[^@]+@([^:]+):(\d+)>/
+        @filename = $1
+        @line = $2.to_i
+      end
+  end
+end

data/lib/nitrous/test_context.rb

@@ -0,0 +1,76 @@
+require 'nitrous/progress_bar'
+module Nitrous
+  class TestContext
+    def self.gui?
+      !!ENV["TM_MODE"] || !!ENV["VIMRUNTIME"]
+    end
+
+    def self.create(test_count)
+      if gui?
+        TestContext.new(test_count)
+      else
+        CommandLineTestContext.new(test_count)
+      end
+    end
+
+    def initialize(test_count)
+      @start_time = Time.now
+      @total, @failures, @test, @skip = test_count, 0, 0, 0
+    end
+
+    def ran_test(test, result)
+      @test += 1
+      @skip += 1 if test.skip?
+      puts result
+      puts result.errors.map(&:test_output).join("\n\n") + "\n" unless result.errors.empty?
+    end
+
+    def failed(exception)
+      @failures += 1
+    end
+
+    def finish
+      puts summary_with_benchmark
+    end
+    
+    def exit_status
+      @failures > 0 ? 1 : 0
+    end
+
+    def summary
+      "Test #{@test} of #{@total} -- #{@failures} failure#{@failures == 1 ? '' : 's'} -- #{@skip} skipped"
+    end
+
+    def summary_with_benchmark
+      summary + " -- #{Time.now - @start_time} seconds"
+    end
+  end
+
+  class CommandLineTestContext < TestContext
+    def initialize(test_count)
+      super
+      @progress_bar = ProgressBar.new(test_count)
+      update_text
+    end
+
+    def ran_test(test, result)
+      super
+      @progress_bar.step
+      update_text
+    end
+
+    def update_text
+      @progress_bar.text = summary
+    end
+
+    def failed(exception)
+      super
+      @progress_bar.color = ProgressBar::RED
+    end
+
+    def finish
+      @progress_bar.text = summary_with_benchmark
+      @progress_bar.draw
+    end
+  end
+end

data/lib/nitrous/test_result.rb

@@ -0,0 +1,17 @@
+module Nitrous
+  class TestResult
+    attr_reader :errors
+    def initialize(test)
+      @test, @errors = test, []
+    end
+
+    def to_s
+      %{  #{@test}: #{pass_fail_skip}}
+    end
+
+    def pass_fail_skip
+      return "Skipped" if @test.skip?
+      @errors.empty? ? "Passed" : "Failed"
+    end
+  end
+end

data/lib/rails_ext.rb

@@ -0,0 +1,60 @@
+if defined?(ActiveRecord)
+  unless ActiveRecord::Base.instance_methods.include?('save_with_tracking')
+    class ActiveRecord::Base
+      cattr_accessor :saved_objects
+      cattr_accessor :invalid_objects
+      cattr_accessor :destroyed_objects
+    
+      def create_or_update_with_tracking(*args)
+        new_record = new_record?
+        saved = create_or_update_without_tracking(*args)
+        append_instance(ActiveRecord::Base.saved_objects) if new_record && saved
+        saved
+      end
+      alias_method_chain :create_or_update, :tracking
+
+      def destroy_with_tracking(*args)
+        result = destroy_without_tracking(*args)
+        append_instance(ActiveRecord::Base.destroyed_objects) if result
+        result
+      end
+      alias_method_chain :destroy, :tracking
+    
+      def validate_with_tracking(*args)
+        valid = validate_without_tracking(*args)
+        append_instance(ActiveRecord::Base.invalid_objects) if !valid
+        valid
+      end
+      alias_method_chain :validate, :tracking
+    
+      private
+        def append_instance(list)
+          return if !list
+          key = self.class.name.underscore.to_sym
+          list[key] ||= []
+          list[key] << self
+        end
+    end
+  end
+end
+module Extensions
+  module Core
+    module Hash
+      def to_fields(fields = {}, namespace = nil)
+        each do |key, value|
+          key = namespace ? "#{namespace}[#{key}]" : key
+          case value
+          when ::Hash
+            value.to_fields(fields, key)
+          when ::Array
+            fields["#{key}[]"] = value
+          else
+            fields[key.to_s] = value
+          end
+        end
+        fields
+      end
+    end
+  end
+end
+Hash.send :include, Extensions::Core::Hash