micronaut 0.2.9

data/lib/micronaut/formatters/base_text_formatter.rb

@@ -0,0 +1,139 @@
+module Micronaut
+
+  module Formatters
+
+    class BaseTextFormatter < BaseFormatter
+      
+      def dump_failures
+        output.puts
+        failed_examples.each_with_index do |failed_example, index|
+          exception = failed_example.execution_result[:exception_encountered]
+          padding = '    '
+          
+          output.puts "#{index.next}) #{failed_example}"
+          output.puts "#{padding}Failure/Error: #{read_failed_line(exception, failed_example).strip}"
+          
+          exception.message.split("\n").each do |line|
+            output.puts "#{padding}#{colorise(line, exception).strip}"
+          end
+
+          format_backtrace(exception.backtrace, failed_example).each do |backtrace_info|
+            output.puts grey("#{padding}# #{backtrace_info}")
+          end
+          
+          output.puts 
+          output.flush
+        end
+      end
+
+      def colorise(s, failure)
+        if failure.is_a?(Micronaut::Expectations::ExpectationNotMetError)
+          red(s)
+        else
+          magenta(s)
+        end
+      end
+
+      def dump_summary
+        failure_count = failed_examples.size
+        pending_count = pending_examples.size
+
+        output.puts "\nFinished in #{duration} seconds\n"
+
+        summary = "#{example_count} example#{'s' unless example_count == 1}, #{failure_count} failures"
+        summary << ", #{pending_count} pending" if pending_count > 0  
+
+        if failure_count == 0
+          if pending_count > 0
+            output.puts yellow(summary)
+          else
+            output.puts green(summary)
+          end
+        else
+          output.puts red(summary)
+        end
+        
+        # Don't print out profiled info if there are failures, it just clutters the output
+        if profile_examples? && failure_count == 0
+          sorted_examples = examples.sort_by { |example| example.execution_result[:run_time] }.reverse.first(10)
+          output.puts "\nTop #{sorted_examples.size} slowest examples:\n"        
+          sorted_examples.each do |example|
+            output.puts "  (#{sprintf("%.7f", example.execution_result[:run_time])} seconds) #{example}"
+            output.puts grey("   # #{format_caller(example.metadata[:caller])}")
+          end
+        end
+        
+        output.flush
+      end
+      
+      # def textmate_link_backtrace(path)
+      #   file, line = path.split(':')
+      #   "txmt://open/?url=file://#{File.expand_path(file)}&line=#{line}"
+      # end
+      
+      def format_caller(caller_info)
+        caller_info.to_s.split(':in `block').first
+      end
+
+      def dump_pending
+        unless pending_examples.empty?
+          output.puts
+          output.puts "Pending:"
+          pending_examples.each do |pending_example, message|
+            output.puts "  #{pending_example}"
+            output.puts grey("   # #{format_caller(pending_example.metadata[:caller])}")
+          end
+        end
+        output.flush
+      end
+
+      def close
+        if IO === output && output != $stdout
+          output.close 
+        end
+      end
+
+      protected
+
+      def color(text, color_code)
+        return text unless color_enabled?
+        "#{color_code}#{text}\e[0m"
+      end
+      
+      def bold(text)
+        color(text, "\e[1m")
+      end
+      
+      def white(text)
+        color(text, "\e[37m")
+      end
+
+      def green(text)
+        color(text, "\e[32m")
+      end
+
+      def red(text)
+        color(text, "\e[31m")
+      end
+
+      def magenta(text)
+        color(text, "\e[35m")
+      end
+
+      def yellow(text)
+        color(text, "\e[33m")
+      end
+
+      def blue(text)
+        color(text, "\e[34m")
+      end
+      
+      def grey(text)
+        color(text, "\e[90m")
+      end
+
+    end
+    
+  end
+
+end

data/lib/micronaut/formatters/documentation_formatter.rb

@@ -0,0 +1,78 @@
+module Micronaut
+  module Formatters
+
+    class DocumentationFormatter < BaseTextFormatter
+
+      attr_reader :previous_nested_behaviours
+
+      def initialize
+        super
+        @previous_nested_behaviours = []
+      end
+
+      def add_behaviour(behaviour)
+        super
+
+        described_behaviour_chain.each_with_index do |nested_behaviour, i|
+          unless nested_behaviour == previous_nested_behaviours[i]
+            at_root_level = (i == 0)
+            desc_or_name = at_root_level ? nested_behaviour.name : nested_behaviour.description
+            output.puts if at_root_level
+            output.puts "#{'  ' * i}#{desc_or_name}"
+          end
+        end
+        
+        @previous_nested_behaviours = described_behaviour_chain
+      end
+
+      def output_for(example)
+        case example.execution_result[:status]
+        when 'failed'
+          failure_output(example, example.execution_result[:exception_encountered])
+        when 'pending'
+          pending_output(example, example.execution_result[:pending_message])
+        when 'passed'
+          passed_output(example)
+        else
+          red(example.execution_result[:status])
+        end
+      end
+
+      def example_finished(example)
+        super
+        output.puts output_for(example)
+        output.flush
+      end
+
+      def failure_output(example, exception)
+        expectation_not_met = exception.is_a?(::Micronaut::Expectations::ExpectationNotMetError)
+        
+        message = if expectation_not_met
+          "#{current_indentation}#{example.description} (FAILED)"
+        else
+          "#{current_indentation}#{example.description} (ERROR)"
+        end
+
+        expectation_not_met ? red(message) : magenta(message)
+      end
+
+      def passed_output(example)
+        green("#{current_indentation}#{example.description}")
+      end
+
+      def pending_output(example, message)
+        yellow("#{current_indentation}#{example.description} (PENDING: #{message})")
+      end
+
+      def current_indentation
+        '  ' * previous_nested_behaviours.size
+      end
+
+      def described_behaviour_chain
+        behaviour.ancestors
+      end
+
+    end
+    
+  end
+end

data/lib/micronaut/formatters/progress_formatter.rb

@@ -0,0 +1,30 @@
+module Micronaut
+  module Formatters
+    
+    class ProgressFormatter < BaseTextFormatter
+      
+      def output_for(example)
+        case example.execution_result[:status]
+        when 'failed' then colorise('F', example.execution_result[:exception_encountered])
+        when 'pending' then yellow('*')
+        when 'passed' then green('.')
+        else
+          red(example.execution_result[:status])
+        end
+      end
+
+      def example_finished(example)
+        super
+        output.print output_for(example)
+      end
+
+      def start_dump(duration)
+        super
+        output.puts
+        output.flush
+      end
+
+    end
+    
+  end
+end

data/lib/micronaut/kernel_extensions.rb

@@ -0,0 +1,11 @@
+module Micronaut
+  module KernelExtensions
+
+    def describe(*args, &behaviour_block)
+      Micronaut::Behaviour.describe(*args, &behaviour_block)
+    end
+
+  end
+end
+
+include Micronaut::KernelExtensions

data/lib/micronaut/matchers.rb

@@ -0,0 +1,141 @@
+require 'micronaut/matchers/generated_descriptions'
+require 'micronaut/matchers/simple_matcher'
+require 'micronaut/matchers/be'
+require 'micronaut/matchers/be_close'
+require 'micronaut/matchers/change'
+require 'micronaut/matchers/eql'
+require 'micronaut/matchers/equal'
+require 'micronaut/matchers/has'
+require 'micronaut/matchers/have'
+require 'micronaut/matchers/include'
+require 'micronaut/matchers/match'
+require 'micronaut/matchers/raise_error'
+require 'micronaut/matchers/respond_to'
+require 'micronaut/matchers/satisfy'
+require 'micronaut/matchers/throw_symbol'
+require 'micronaut/matchers/operator_matcher'
+
+module Micronaut
+
+  # We ship (courtesy of RSpec and Micronaut) with a number of useful Expression Matchers. An Expression Matcher
+  # is any object that responds to the following methods:
+  #
+  #   matches?(actual)
+  #   failure_message
+  #   negative_failure_message #optional
+  #   description #optional
+  #
+  # See Micronaut::Expectations to learn how to use these as Expectation Matchers.
+  # See Micronaut::Mocks to learn how to use them as Mock Argument Constraints.
+  #
+  # == Predicates
+  #
+  # In addition to those Expression Matchers that are defined explicitly, we will
+  # create custom Matchers on the fly for any arbitrary predicate, giving your specs
+  # a much more natural language feel. 
+  #
+  # A Ruby predicate is a method that ends with a "?" and returns true or false.
+  # Common examples are +empty?+, +nil?+, and +instance_of?+.
+  #
+  # All you need to do is write +should be_+ followed by the predicate without
+  # the question mark, and we will figure it out from there. For example:
+  #
+  #   [].should be_empty => [].empty? #passes
+  #   [].should_not be_empty => [].empty? #fails
+  #
+  # In addtion to prefixing the predicate matchers with "be_", you can also use "be_a_"
+  # and "be_an_", making your specs read much more naturally:
+  #
+  #   "a string".should be_an_instance_of(String) =>"a string".instance_of?(String) #passes
+  #
+  #   3.should be_a_kind_of(Fixnum) => 3.kind_of?(Numeric) #passes
+  #   3.should be_a_kind_of(Numeric) => 3.kind_of?(Numeric) #passes
+  #   3.should be_an_instance_of(Fixnum) => 3.instance_of?(Fixnum) #passes
+  #   3.should_not be_instance_of(Numeric) => 3.instance_of?(Numeric) #fails
+  #
+  # We will also create custom matchers for predicates like +has_key?+. To
+  # use this feature, just state that the object should have_key(:key) and we will
+  # call has_key?(:key) on the target. For example:
+  #
+  #   {:a => "A"}.should have_key(:a) => {:a => "A"}.has_key?(:a) #passes
+  #   {:a => "A"}.should have_key(:b) => {:a => "A"}.has_key?(:b) #fails
+  #
+  # You can use this feature to invoke any predicate that begins with "has_", whether it is
+  # part of the Ruby libraries (like +Hash#has_key?+) or a method you wrote on your own class.
+  #
+  # == Custom Expectation Matchers
+  #
+  # When you find that none of the stock Expectation Matchers provide a natural
+  # feeling expectation, you can very easily write your own.
+  #
+  # For example, imagine that you are writing a game in which players can
+  # be in various zones on a virtual board. To specify that bob should
+  # be in zone 4, you could say:
+  #
+  #   bob.current_zone.should eql(Zone.new("4"))
+  #
+  # But you might find it more expressive to say:
+  #
+  #   bob.should be_in_zone("4")
+  #
+  # and/or
+  #
+  #   bob.should_not be_in_zone("3")
+  #
+  # To do this, you would need to write a class like this:
+  #
+  #   class BeInZone
+  #     def initialize(expected)
+  #       @expected = expected
+  #     end
+  #     def matches?(target)
+  #       @target = target
+  #       @target.current_zone.eql?(Zone.new(@expected))
+  #     end
+  #     def failure_message
+  #       "expected #{@target.inspect} to be in Zone #{@expected}"
+  #     end
+  #     def negative_failure_message
+  #       "expected #{@target.inspect} not to be in Zone #{@expected}"
+  #     end
+  #   end
+  #
+  # ... and a method like this:
+  #
+  #   def be_in_zone(expected)
+  #     BeInZone.new(expected)
+  #   end
+  #
+  # And then expose the method to your specs. This is normally done
+  # by including the method and the class in a module, which is then
+  # included in your spec:
+  #
+  #   module CustomGameMatchers
+  #     class BeInZone
+  #       ...
+  #     end
+  #
+  #     def be_in_zone(expected)
+  #       ...
+  #     end
+  #   end
+  #
+  #   describe "Player behaviour" do
+  #     include CustomGameMatchers
+  #     ...
+  #   end
+
+  module Matchers
+    
+    class MatcherError < StandardError; end
+    
+    private
+    def method_missing(sym, *args, &block) # :nodoc:
+      return Matchers::Be.new(sym, *args) if sym.to_s =~ /^be_/
+      return has(sym, *args) if sym.to_s =~ /^have_/
+      super
+    end
+      
+  end
+  
+end

data/lib/micronaut/matchers/be.rb

@@ -0,0 +1,204 @@
+module Micronaut
+  module Matchers
+    
+    class Be #:nodoc:
+      def initialize(*args)
+        @expected = args.empty? ? true : set_expected(args.shift)
+        @args = args
+      end
+      
+      def matches?(actual)
+        @actual = actual
+        handling_predicate? ? run_predicate_on(actual) : match_or_compare(actual)
+      end
+      
+      def run_predicate_on(actual)
+        begin
+          return @result = actual.__send__(predicate, *@args)
+        rescue NameError => predicate_missing_error
+          "this needs to be here or rcov will not count this branch even though it's executed in a code example"
+        end
+
+        begin
+          return @result = actual.__send__(present_tense_predicate, *@args)
+        rescue NameError
+          raise predicate_missing_error
+        end
+      end
+      
+      def failure_message
+        handling_predicate? ?
+          "expected #{predicate}#{args_to_s} to return true, got #{@result.inspect}" :
+          "expected #{@comparison_method} #{expected}, got #{@actual.inspect}".gsub('  ',' ')
+      end
+      
+      def negative_failure_message
+        if handling_predicate?
+          "expected #{predicate}#{args_to_s} to return false, got #{@result.inspect}"
+        else
+          message = <<-MESSAGE
+'should_not be #{@comparison_method} #{expected}' not only FAILED,
+it reads really poorly.
+          MESSAGE
+          
+          raise message << ([:===,:==].include?(@comparison_method) ?
+            "Why don't you try expressing it without the \"be\"?" :
+            "Why don't you try expressing it in the positive?")
+        end
+      end
+      
+      def description
+        "#{prefix_to_sentence}#{comparison} #{expected_to_sentence}#{args_to_sentence}".gsub(/\s+/,' ')
+      end
+
+      [:==, :<, :<=, :>=, :>, :===].each do |method|
+        define_method method do |expected|
+          compare_to(expected, :using => method)
+          self
+        end
+      end
+
+      private
+        def match_or_compare(actual)
+          case @expected
+          when TrueClass
+            @actual
+          else
+            @actual.__send__(comparison_method, @expected)
+          end
+        end
+      
+        def comparison_method
+          @comparison_method || :equal?
+        end
+      
+        def expected
+          @expected
+        end
+
+        def compare_to(expected, opts)
+          @expected, @comparison_method = expected, opts[:using]
+        end
+
+        def set_expected(expected)
+          Symbol === expected ? parse_expected(expected) : expected
+        end
+        
+        def parse_expected(expected)
+          ["be_an_","be_a_","be_"].each do |prefix|
+            handling_predicate!
+            if expected.to_s =~ /^#{prefix}/
+              set_prefix(prefix)
+              expected = expected.to_s.sub(prefix,"")
+              [true, false, nil].each do |val|
+                return val if val.to_s == expected
+              end
+              return expected.to_sym
+            end
+          end
+        end
+        
+        def set_prefix(prefix)
+          @prefix = prefix
+        end
+        
+        def prefix
+          @prefix
+        end
+
+        def handling_predicate!
+          @handling_predicate = true
+        end
+        
+        def handling_predicate?
+          return false if [true, false, nil].include?(expected)
+          return @handling_predicate
+        end
+
+        def predicate
+          "#{@expected.to_s}?".to_sym
+        end
+        
+        def present_tense_predicate
+          "#{@expected.to_s}s?".to_sym
+        end
+        
+        def args_to_s
+          @args.empty? ? "" : parenthesize(inspected_args.join(', '))
+        end
+        
+        def parenthesize(string)
+          return "(#{string})"
+        end
+        
+        def inspected_args
+          @args.collect{|a| a.inspect}
+        end
+        
+        def comparison
+          @comparison_method.nil? ? " " : "be #{@comparison_method.to_s} "
+        end
+        
+        def expected_to_sentence
+          split_words(expected)
+        end
+        
+        def prefix_to_sentence
+          split_words(prefix)
+        end
+
+        def split_words(sym)
+          sym.to_s.gsub(/_/,' ')
+        end
+
+        def args_to_sentence
+          case @args.length
+            when 0
+              ""
+            when 1
+              " #{@args[0]}"
+            else
+              " #{@args[0...-1].join(', ')} and #{@args[-1]}"
+          end
+        end
+        
+    end
+ 
+    # :call-seq:
+    #   should be_true
+    #   should be_false
+    #   should be_nil
+    #   should be_arbitrary_predicate(*args)
+    #   should_not be_nil
+    #   should_not be_arbitrary_predicate(*args)
+    #
+    # Given true, false, or nil, will pass if actual value is
+    # true, false or nil (respectively). Given no args means
+    # the caller should satisfy an if condition (to be or not to be). 
+    #
+    # Predicates are any Ruby method that ends in a "?" and returns true or false.
+    # Given be_ followed by arbitrary_predicate (without the "?"), we will match
+    # convert that into a query against the target object.
+    #
+    # The arbitrary_predicate feature will handle any predicate
+    # prefixed with "be_an_" (e.g. be_an_instance_of), "be_a_" (e.g. be_a_kind_of)
+    # or "be_" (e.g. be_empty), letting you choose the prefix that best suits the predicate.
+    #
+    # == Examples 
+    #
+    #   target.should be_true
+    #   target.should be_false
+    #   target.should be_nil
+    #   target.should_not be_nil
+    #
+    #   collection.should be_empty #passes if target.empty?
+    #   "this string".should be_an_intance_of(String)
+    #
+    #   target.should_not be_empty #passes unless target.empty?
+    #   target.should_not be_old_enough(16) #passes unless target.old_enough?(16)
+    def be(*args)
+      Matchers::Be.new(*args)
+    end
+
+  end
+end