eetee 0.0.1

data/lib/eetee/reporter.rb

@@ -0,0 +1,62 @@
+module EEtee
+  class Reporter
+    attr_reader :failures, :errors, :assertion_count, :test_count
+    
+    def initialize
+      @errors = []
+      @failures = []
+      @empty = []
+      
+      @indent = 0
+      @assertion_count = 0
+      @test_count = 0
+      
+      @started_at = Time.now
+    end
+    
+    def increment_assertions
+      @assertion_count += 1
+    end
+    
+    def around_context(ctx, &block)
+      @indent += 1
+      block.call()
+    ensure
+      @indent -= 1
+    end
+    
+    def around_test(test, &block)
+      before_assertions = @assertion_count
+      
+      block.call()
+      
+      if before_assertions == @assertion_count
+        @empty << test
+        :empty
+      else
+        @test_count += 1
+        :ok
+      end
+      
+    rescue EEtee::AssertionFailed => err
+      @failures << err
+      :failed
+      
+    rescue EEtee::Error => err
+      @errors << err
+      :error
+    end
+    
+  end
+  
+  
+  def report_results
+    # no op
+  end
+
+private
+  def elapsed_time
+    Time.now.to_i - @started_at.to_i
+  end
+  
+end

data/lib/eetee/reporters/console.rb

@@ -0,0 +1,123 @@
+# encoding: utf-8
+
+require 'term/ansicolor'
+
+module EEtee
+  module Reporters
+    
+    ##
+    # Advanced text output designed to be used in a open
+    # console.
+    # 
+    class Console < Reporter
+      Color = Term::ANSIColor
+      
+      def around_context(ctx, &block)
+        puts "" if @indent == 0
+        # iputs "# #{ctx.description}:"
+        
+        iputs "#{Color.underscore}#{ctx.description}#{Color.reset}"
+        super
+        
+        puts "" if @indent == 0
+      end
+      
+      def around_test(test, &block)
+        iprint " ~ #{test.label}"
+        
+        ret = super
+        
+        # goto beginning of line
+        print "\e[G\e[K"
+
+        
+        case ret
+        when :empty   then iputs " #{Color.red}✘#{Color.reset} #{test.label}"
+        when :ok      then iputs " #{Color.green}✔#{Color.reset} #{test.label}"
+        when :failed  then iputs " #{Color.red}✘#{Color.reset} #{test.label}"
+        when :error   then iputs " #{Color.red}☁ #{test.label}#{Color.reset} [#{@errors[-1].class}]"
+        end
+      end
+      
+      def report_results
+        report_failures() unless @failures.empty?
+        report_errors() unless @errors.empty?
+        report_empty() unless @empty.empty?
+        
+        puts ""
+        puts "#{@test_count} Tests / #{@assertion_count} Assertions"
+        puts "#{@errors.size} Errors / #{@failures.size} failures"
+        if elapsed_time() == 0
+          puts "Execution time: < 1s"
+        else
+          puts "Execution time: #{human_duration(elapsed_time)}"
+        end
+      end
+
+    private
+      
+      def spaces(str = "  ")
+        str * @indent
+      end
+      
+      def iprint(msg)
+        tmp = '  ' * @indent
+        Kernel.print("#{tmp}#{msg}")
+      end
+
+      def iputs(msg)
+        iprint("#{msg}\n")
+      end
+      
+      def human_duration(secs)
+        [[60, 'seconds'], [60, 'minutes'], [24, 'hours'], [1000, 'days']].map do |count, name|
+          if secs > 0
+            secs, n = secs.divmod(count)
+            (n > 0) ? "#{n.to_i} #{name}" : nil
+          end
+        end.compact.reverse.join(' ')
+      end
+      
+      def report_empty
+        puts "\nEmpty tests:"
+        @empty.each do |test|
+          puts "- #{test.label}"
+        end
+      end
+      
+      def report_failures
+        puts "\nFailures:"
+        @failures.each do |f|
+          puts "- #{f.test.label}: #{f.message}"
+          dump_trace(f)
+        end
+      end
+      
+      def report_errors
+        puts "\nErrors:"
+        @errors.each do |err|
+          puts "#{err.test.label}:"
+          puts "    #{err.error.class} #{err.error}"
+          dump_trace(err.error)
+        end
+      end
+      
+      def dump_trace(err, cleanup = true)
+        lines = err.backtrace
+        
+        if cleanup
+          lines.reject! do |line|
+            line.include?('.rbenv')
+          end
+        end
+        
+        lines.each do |line|
+          puts "      #{line}"
+        end
+
+      end
+      
+    end
+    
+  end
+end

data/lib/eetee/reporters/text.rb

@@ -0,0 +1,80 @@
+module EEtee
+  module Reporters
+    
+    ##
+    # Basic text output.
+    # 
+    class Text < Reporter
+      
+      
+      def around_context(ctx, &block)
+        puts "" if @indent == 0
+        iputs "# #{ctx.description}:"
+        super
+      end
+      
+      def around_test(test, &block)
+        iprint "- #{test.label}... "
+        case super
+        when :empty   then puts "EMPTY"
+        when :ok      then puts "OK"
+        when :failed  then puts "FAILED"
+        when :error   then puts "ERROR"
+        end
+      end
+      
+      def report_results
+        report_failures() unless @failures.empty?
+        report_errors() unless @errors.empty?
+        
+        puts ""
+        puts "#{@test_count} Tests / #{@assertion_count} Assertions"
+        puts "#{@errors.size} Errors / #{@failures.size} failures"
+      end
+
+    private
+      def iprint(msg)
+        tmp = '  ' * @indent
+        Kernel.print("#{tmp}#{msg}")
+      end
+
+      def iputs(msg)
+        iprint("#{msg}\n")
+      end
+      
+      def report_failures
+        puts "\nFailures:"
+        @failures.each do |f|
+          puts "- #{f.test.label}: #{f.message}"
+          dump_trace(f)
+        end
+      end
+      
+      def report_errors
+        puts "\nErrors:"
+        @errors.each do |err|
+          puts "#{err.test.label}:"
+          puts "    #{err.error.class} #{err.error}"
+          dump_trace(err.error)
+        end
+      end
+      
+      def dump_trace(err, cleanup = true)
+        lines = err.backtrace
+        
+        if cleanup
+          lines.reject! do |line|
+            line.include?('gems')
+          end
+        end
+        
+        lines.each do |line|
+          puts "      #{line}"
+        end
+
+      end
+      
+    end
+    
+  end
+end

data/lib/eetee/runner.rb

@@ -0,0 +1,62 @@
+require 'forwardable'
+
+module EEtee
+    
+  class Runner
+    extend Forwardable
+    attr_reader :focus_mode
+    
+    def_delegators :@reporter, :failures, :errors, :assertions, :test_count
+    
+    def initialize
+      @reporter = EEtee.default_reporter_class.new
+      @focus_mode = false
+    end
+    
+    def run(&block)
+      instance_eval(&block)
+      @reporter.report_results()
+    end
+    
+    def run_pattern(pattern)
+      paths = []
+      caller_path = caller[0].split(':').first
+      pattern = File.expand_path("../#{pattern}", caller_path)
+      
+      paths = Dir[pattern].to_a
+      run_files(paths)
+    end
+    
+    ##
+    # run the files relative to the caller.
+    # 
+    def run_files(paths)
+      paths.each do |path|
+        if File.exist?(path)
+          data = File.read(path)
+          if data =~ /^\s+should.*?,\s+:focus => true do$/
+            puts "Focus enabled."
+            @focus_mode = true
+          else
+            @focus_mode = false
+          end
+          instance_eval(data, path)
+        else
+          puts "!!! file does not exists: #{path}"
+        end
+      end
+      
+    rescue SyntaxError => ex
+      puts ex.message
+    end
+    
+    def report_results
+      @reporter.report_results()
+    end
+    
+    def describe(description, &block)
+      Context.new(description, 0, @reporter, {}, @focus_mode, &block)
+    end
+  end
+  
+end

data/lib/eetee/shared.rb

@@ -0,0 +1,27 @@
+module EEtee
+  class Shared
+    attr_accessor :_reporter, :_level
+    
+    include SharedContextMethods
+    
+    @@shared = {}
+    
+    def self.run(name, reporter, level, *args)
+      sh = @@shared[name]
+      sh._reporter = reporter
+      sh._level = level
+      sh.run(*args)
+    end
+    
+    
+    def initialize(name, &block)
+      @@shared[name] = self
+      @_block = block
+    end
+    
+    def run(*args)
+      instance_exec(*args, &@_block)
+    end
+    
+  end
+end

data/lib/eetee/test.rb

@@ -0,0 +1,40 @@
+require 'thread'
+
+module EEtee
+  
+  module TestBaseExtension
+    def run(&block)
+      block.call()
+    end
+  end
+  
+  class Test
+    attr_reader :label, :reporter
+    
+    include TestBaseExtension
+    
+    def initialize(label, reporter, &block)
+      @label = label
+      @reporter = reporter || raise('missing reporter')
+      @reporter.around_test(self) do
+        run(&block)
+      end
+    end
+    
+    def run(&block)
+      EEtee.current_test = self
+      super(&block)
+            
+    rescue AssertionFailed => err
+      err.test = self
+      ::Kernel.raise
+      
+    rescue => err
+      ::Kernel.raise Error.new(err, self)
+    ensure
+      EEtee.current_test = nil
+    end
+    
+  end
+
+end

data/lib/eetee/version.rb

@@ -0,0 +1,3 @@
+module EEtee
+  VERSION = "0.0.1"
+end

data/lib/eetee.rb

@@ -0,0 +1,65 @@
+require_relative 'eetee/version'
+
+require_relative 'eetee/reporter'
+require_relative 'eetee/reporters/text'
+require_relative 'eetee/reporters/console'
+
+require_relative 'eetee/errors'
+require_relative 'eetee/assertion_wrapper'
+require_relative 'eetee/test'
+require_relative 'eetee/context'
+require_relative 'eetee/shared'
+require_relative 'eetee/runner'
+
+
+
+module EEtee
+  class << self
+    def default_reporter_class=(reporter)
+      @reporter = reporter
+    end
+    
+    def default_reporter_class
+      @reporter
+    end
+    
+    def enable_focus_mode=(value)
+      @enable_focus_mode = value
+    end
+    
+    def enable_focus_mode
+      @enable_focus_mode
+    end
+  end
+  
+  
+  def self.current_test
+    Thread.current[:eetee_test]
+  end
+  
+  def self.current_test=(test)
+    Thread.current[:eetee_test] = test
+  end
+  
+  
+  module AssertionHelpers
+    def should()
+      EEtee::AssertionWrapper.new(self)
+    end
+  end
+
+  def describe(description, enable_focus_mode = EEtee.enable_focus_mode, &block)
+    reporter = EEtee.default_reporter_class.new
+    Context.new(description, 0, reporter, {}, enable_focus_mode, &block)
+    reporter.report_results()
+  end
+  
+  def shared(name, &block)
+    Shared.new(name, &block)
+  end
+  
+  self.default_reporter_class = Reporters::Console
+end
+
+include EEtee
+Object.__send__(:include, EEtee::AssertionHelpers)

data/lib/guard/eetee.rb

@@ -0,0 +1,77 @@
+require 'guard'
+require 'guard/guard'
+
+gem 'guard', '~> 1.5.3'
+
+module Guard
+  class EEtee < Guard
+
+    # Initialize a Guard.
+    # @param [Array<Guard::Watcher>] watchers the Guard file watchers
+    # @param [Hash] options the custom Guard options
+    def initialize(watchers = [], options = {})
+      super
+    end
+
+    # Call once when Guard starts. Please override initialize method to init stuff.
+    # @raise [:task_has_failed] when start has failed
+    def start
+      puts "Guard::EEtee started."
+    end
+
+    # Called when `stop|quit|exit|s|q|e + enter` is pressed (when Guard quits).
+    # @raise [:task_has_failed] when stop has failed
+    def stop
+      puts "Guard::EEtee stopped."
+    end
+
+    # Called when `reload|r|z + enter` is pressed.
+    # This method should be mainly used for "reload" (really!) actions like reloading passenger/spork/bundler/...
+    # @raise [:task_has_failed] when reload has failed
+    def reload
+      
+    end
+
+    # Called when just `enter` is pressed
+    # This method should be principally used for long action like running all specs/tests/...
+    # @raise [:task_has_failed] when run_all has failed
+    def run_all
+    end
+
+    # Called on file(s) modifications that the Guard watches.
+    # @param [Array<String>] paths the changes files or paths
+    # @raise [:task_has_failed] when run_on_change has failed
+    def run_on_changes(paths)
+      pid = Kernel.fork do
+        require 'eetee'
+        runner = EEtee::Runner.new
+        runner.run_files(paths)
+        runner.report_results()
+        
+        tests = runner.test_count
+        failures = runner.failures.size + runner.errors.size
+        
+        focus_mode = runner.focus_mode
+        
+        if failures > 0
+          Notifier.notify("Specs: #{failures} Failures (#{tests} tests) #{focus_mode ? '(focus)' : ''}",
+              :image => :failed
+            )
+        else
+          Notifier.notify("Specs: OK (#{tests} tests) #{focus_mode ? '(focus)' : ''}",
+              :image => :success
+            )
+        end
+      end
+      
+      Process.wait(pid)
+    end
+
+    # Called on file(s) deletions that the Guard watches.
+    # @param [Array<String>] paths the deleted files or paths
+    # @raise [:task_has_failed] when run_on_change has failed
+    def run_on_removals(paths)
+    end
+
+  end
+end

data/specs/spec_helper.rb

@@ -0,0 +1,11 @@
+require 'rubygems'
+require 'bundler/setup'
+
+require 'eetee'
+
+require 'eetee/ext/mocha'
+
+Thread.abort_on_exception = true
+
+# examples
+require_relative '../examples/extensions/extension'

data/specs/unit/assertion_wrapper_spec.rb

@@ -0,0 +1,134 @@
+require File.expand_path('../../spec_helper', __FILE__)
+
+module Helpers
+  def ensure_error_not_raised
+    ret = nil
+    begin
+      yield
+    rescue => err
+      ret = err
+    end
+    
+    ret.should == nil
+  end
+  
+  def ensure_error_raised(error_class)
+    ret = nil
+    begin
+      yield
+    rescue error_class => err
+      ret = err
+    end
+    
+    ret.class.should == error_class
+  end
+end
+
+EEtee::Context.__send__(:include, Helpers)
+
+describe 'AssertionWrapper' do
+  before do
+    @obj = stub('Object')
+    @wrapper = EEtee::AssertionWrapper.new(@obj)
+  end
+  
+  should 'call method on the targeted object' do
+    @obj.expects(:to_zebra).returns(3)
+    @wrapper.to_zebra
+  end
+  
+  should 'not raise an error if methods return anything else' do
+    @obj.expects(:to_zebra).returns(3)
+    ensure_error_not_raised do
+      @wrapper.to_zebra
+    end
+  end
+  
+  
+  describe 'assertions' do
+    describe 'any method' do
+      should 'not raise an error if it returns a non false value' do
+        @obj.expects(:to_zebra).returns(3)
+        @wrapper.to_zebra
+      end
+      
+      should 'raise an error if it returns a false/nil value' do
+        @obj.expects(:to_zebra).returns(nil)
+        ensure_error_raised(EEtee::AssertionFailed) do
+          @wrapper.to_zebra
+        end
+      end
+      
+      should '[inverted] not raise an error if it returns a false/nil value' do
+        @obj.expects(:to_zebra).returns(nil)
+        ensure_error_not_raised do
+          @wrapper.not.to_zebra
+        end
+      end
+    end
+    
+    describe 'raise' do
+      should 'raise an error if block do not raises expected error' do
+        @obj.expects(:to_zebra).raises("damn !")
+        ensure_error_raised(EEtee::AssertionFailed) do
+          ->{ @wrapper.to_zebra }.should.raise(NoMethodError)
+        end
+      end
+      
+      should 'not raise an error if block raises expected error' do
+        @obj.expects(:to_zebra).raises("damn !")
+        ensure_error_not_raised do
+          ->{ @wrapper.to_zebra }.should.raise(RuntimeError)
+        end
+      end
+      
+      should '[inverted] raise an error if block raises expected error' do
+        @obj.expects(:to_zebra).raises("damn !")
+        ensure_error_raised(EEtee::AssertionFailed) do
+          ->{ @wrapper.to_zebra }.should.not.raise(RuntimeError)
+        end
+      end
+
+    end
+    
+    describe 'be_a' do
+      should 'not raise an error if class match' do
+        w1 = EEtee::AssertionWrapper.new("string")
+        w1.be_a String
+        
+        w1 = EEtee::AssertionWrapper.new(4)
+        w1.be_a Fixnum
+      end
+      
+      should 'raise an error unless class match' do
+        w1 = EEtee::AssertionWrapper.new("string")
+        ->{ w1.be_a Fixnum }.should.raise(EEtee::AssertionFailed)
+        
+        w1 = EEtee::AssertionWrapper.new(3)
+        ->{ w1.be_a String }.should.raise(EEtee::AssertionFailed)
+      end
+
+    end
+    
+    describe 'be' do
+      should 'be transparent (syntax sugar)' do
+        w1 = EEtee::AssertionWrapper.new("string")
+        w1.be == "string"
+      end
+    end
+    
+    describe 'close?' do
+      should 'not raise an error if number in range' do
+        w1 = EEtee::AssertionWrapper.new(3.4)
+        w1.close?(3, 0.4)
+      end
+      
+      should 'raise an error if number outside range' do
+        w1 = EEtee::AssertionWrapper.new(3.4)
+        ->{ w1.close?(3, 0.3) }.should.raise(EEtee::AssertionFailed)
+      end
+    end
+    
+  end
+  
+end