rsanheim-micronaut 0.1.3.2

data/lib/micronaut/configuration.rb

@@ -0,0 +1,133 @@
+module Micronaut
+
+  class Configuration
+    # Destired mocking framework - expects the symbol name of the framework
+    # Currently supported: :mocha, :rr, or nothing (the default if this is not set at all)
+    attr_reader :mock_framework
+    
+    # Array of regular expressions to scrub from backtrace
+    attr_reader :backtrace_clean_patterns
+    
+    # An array of arrays to store before and after blocks
+    attr_reader :before_and_afters
+
+    # Filters allow you to exclude or include certain examples from running based on options you pass in 
+    attr_reader :filters
+    
+    # When this is true, if you have filters enabled and no examples match, all examples are added and run - defaults to true
+    attr_accessor :run_all_when_everything_filtered
+
+    # Enable profiling of the top 10 slowest examples - defaults to false
+    attr_accessor :profile_examples
+    
+    def initialize
+      @backtrace_clean_patterns = [/\/lib\/ruby\//, /bin\/rcov:/, /vendor\/rails/]
+      @profile_examples = false
+      @run_all_when_everything_filtered = true
+      @filters = []
+      @before_and_afters = []
+    end
+    
+    def cleaned_from_backtrace?(line)
+      return true if line.starts_with?(::Micronaut::InstallDirectory)
+      
+      @backtrace_clean_patterns.any? do |pattern|
+        line =~ pattern
+      end
+    end
+    
+    def mock_with(make_a_mockery_with=nil)
+      @mock_framework = case make_a_mockery_with
+                        when :mocha
+                          require 'micronaut/mocking/with_mocha'
+                          Micronaut::Mocking::WithMocha
+                        when :rr
+                          require 'micronaut/mocking/with_rr'
+                          Micronaut::Mocking::WithRR
+                        else
+                          Micronaut::Mocking::WithAbsolutelyNothing
+                        end 
+
+      Micronaut::Behaviour.send(:include, @mock_framework)
+    end
+    
+    def autorun!
+      Micronaut::Runner.autorun unless Micronaut::Runner.installed_at_exit?      
+    end
+    
+    def options=(new_options)
+      raise ArguementError unless new_options.is_a?(Micronaut::RunnerOptions)
+      @options = new_options
+    end
+    
+    def options
+      # Do we need this?
+      @options ||= Micronaut::RunnerOptions.new(:color => true, :formatter => :documentation)
+    end
+    
+    def extra_modules
+      @extra_modules ||= []
+    end
+        
+    def include(module_to_include, options={})
+      extra_modules << [:include, module_to_include, options]
+    end
+    
+    def extend(module_to_extend, options={})
+      extra_modules << [:extend, module_to_extend, options]
+    end
+    
+    def find_modules(group)
+      extra_modules.select do |include_or_extend, mod, options|
+        options.all? do |key, value|
+          case value
+          when Hash
+            value.all? { |k, v| group.metadata[key][k] == v }
+          when Regexp
+            group.metadata[key] =~ value
+          when Proc
+            value.call(group.metadata[key]) rescue false
+          else
+            group.metadata[key] == value
+          end
+        end
+      end
+    end
+    
+    def add_filter(options={})
+      filters << options
+    end
+    
+    def run_all_when_everything_filtered?
+      @run_all_when_everything_filtered
+    end
+          
+    def before(type=:each, options={}, &block)
+      before_and_afters << [:before, :each, options, block]
+    end
+    
+    def after(type=:each, options={}, &block)
+      before_and_afters << [:after, :each, options, block]
+    end
+    
+    def find_before_or_after(desired_type, desired_each_or_all, group)
+      before_and_afters.select do |type, each_or_all, options, block|
+        type == desired_type && each_or_all == desired_each_or_all &&
+        options.all? do |key, value|
+          case value
+          when Hash
+            value.all? { |k, v| group.metadata[key][k] == v }
+          when Regexp
+            group.metadata[key] =~ value
+          when Proc
+            value.call(group.metadata[key]) rescue false
+          else
+            group.metadata[key] == value
+          end
+        end
+      end.map { |type, each_or_all, options, block| block }
+    end
+    
+  end
+  
+end

data/lib/micronaut/example.rb

@@ -0,0 +1,28 @@
+module Micronaut
+
+  class Example
+  
+    attr_reader :behaviour, :description, :options, :example_block
+  
+    def initialize(behaviour, desc, options, example_block=nil)
+      @behaviour, @description, @options, @example_block = behaviour, desc, options, example_block
+    end
+    
+    def metadata
+      @metadata ||= behaviour.metadata.dup
+      @metadata[:description] = description
+      @metadata[:options].update(options)
+      @metadata
+    end
+    
+    def inspect
+      "#{behaviour.name} - #{description}"
+    end
+    
+    def to_s
+      inspect
+    end
+  
+  end
+  
+end

data/lib/micronaut/expectations/extensions/object.rb

@@ -0,0 +1,62 @@
+module Micronaut
+  module Expectations
+    # rspec adds #should and #should_not to every Object (and, implicitly, every Class).
+    module ObjectExpectations
+      # :call-seq:
+      #   should(matcher)
+      #   should == expected
+      #   should === expected
+      #   should =~ expected
+      #
+      #   receiver.should(matcher)
+      #     => Passes if matcher.matches?(receiver)
+      #
+      #   receiver.should == expected #any value
+      #     => Passes if (receiver == expected)
+      #
+      #   receiver.should === expected #any value
+      #     => Passes if (receiver === expected)
+      #
+      #   receiver.should =~ regexp
+      #     => Passes if (receiver =~ regexp)
+      #
+      # See Micronaut::Matchers for more information about matchers
+      #
+      # == Warning
+      #
+      # NOTE that this does NOT support receiver.should != expected.
+      # Instead, use receiver.should_not == expected
+      def should(matcher=nil, &block)
+        ExpectationMatcherHandler.handle_matcher(self, matcher, &block)
+      end
+
+      # :call-seq:
+      #   should_not(matcher)
+      #   should_not == expected
+      #   should_not === expected
+      #   should_not =~ expected
+      #
+      #   receiver.should_not(matcher)
+      #     => Passes unless matcher.matches?(receiver)
+      #
+      #   receiver.should_not == expected
+      #     => Passes unless (receiver == expected)
+      #
+      #   receiver.should_not === expected
+      #     => Passes unless (receiver === expected)
+      #
+      #   receiver.should_not =~ regexp
+      #     => Passes unless (receiver =~ regexp)
+      #
+      # See Micronaut::Matchers for more information about matchers
+      def should_not(matcher=nil, &block)
+        NegativeExpectationMatcherHandler.handle_matcher(self, matcher, &block)
+      end
+
+    end
+  end
+end
+
+class Object
+  include Micronaut::Expectations::ObjectExpectations
+end

data/lib/micronaut/expectations/extensions/string_and_symbol.rb

@@ -0,0 +1,19 @@
+module Micronaut
+  module Expectations
+    module StringHelpers
+
+      def starts_with?(prefix)
+        to_s[0..(prefix.to_s.length - 1)] == prefix.to_s
+      end
+
+    end
+  end
+end
+
+class String
+  include Micronaut::Expectations::StringHelpers
+end
+
+class Symbol
+  include Micronaut::Expectations::StringHelpers
+end

data/lib/micronaut/expectations/handler.rb

@@ -0,0 +1,52 @@
+module Micronaut
+  module Expectations
+    class InvalidMatcherError < ArgumentError; end        
+    
+    class ExpectationMatcherHandler        
+
+        def self.handle_matcher(actual, matcher, &block)
+          ::Micronaut::Matchers.last_should = "should"
+          return Micronaut::Matchers::PositiveOperatorMatcher.new(actual) if matcher.nil?
+
+          unless matcher.respond_to?(:matches?)
+            raise InvalidMatcherError, "Expected a matcher, got #{matcher.inspect}."
+          end
+          
+          match = matcher.matches?(actual, &block)
+          ::Micronaut::Matchers.last_matcher = matcher
+          Micronaut::Expectations.fail_with(matcher.failure_message) unless match
+          match
+        end
+
+    end
+
+    class NegativeExpectationMatcherHandler
+
+        def self.handle_matcher(actual, matcher, &block)
+          ::Micronaut::Matchers.last_should = "should not"
+          return Micronaut::Matchers::NegativeOperatorMatcher.new(actual) if matcher.nil?
+          
+          unless matcher.respond_to?(:matches?)
+            raise InvalidMatcherError, "Expected a matcher, got #{matcher.inspect}."
+          end
+
+          unless matcher.respond_to?(:negative_failure_message)
+            Micronaut::Expectations.fail_with(
+<<-EOF
+Matcher does not support should_not.
+See Micronaut::Matchers for more information
+about matchers.
+EOF
+)
+          end
+          match = matcher.matches?(actual, &block)
+          ::Micronaut::Matchers.last_matcher = matcher
+          Micronaut::Expectations.fail_with(matcher.negative_failure_message) if match
+          match
+        end
+        
+    end
+
+  end
+end
+

data/lib/micronaut/expectations/wrap_expectation.rb

@@ -0,0 +1,57 @@
+module Micronaut
+  module Matchers
+    
+    # wraps an expectation in a block that will return true if the
+    # expectation passes and false if it fails (without bubbling up
+    # the failure).
+    #     
+    # This is intended to be used in the context of a simple matcher,
+    # and is especially useful for wrapping multiple expectations or
+    # one or more assertions from test/unit extensions when running
+    # with test/unit.
+    #
+    # == Examples
+    #
+    #   def eat_cheese(cheese)
+    #     simple_matcher do |mouse, matcher|
+    #       matcher.negative_failure_message = "expected #{mouse} not to eat cheese"
+    #       wrap_expectation do |matcher|
+    #         assert_eats_cheese(mouse)
+    #       end
+    #     end
+    #   end
+    #
+    #   describe Mouse do
+    #     it "eats cheese" do
+    #       Mouse.new.should eat_cheese
+    #     end
+    #   end
+    #
+    # You might be wondering "why would I do this if I could just say"
+    # assert_eats_cheese?", a fair question, indeed. You might prefer
+    # to replace the word assert with something more aligned with the
+    # rest of your code examples. You are using rspec, after all.
+    #
+    # The other benefit you get is that you can use the negative version
+    # of the matcher:
+    #
+    #   describe Cat do
+    #     it "does not eat cheese" do
+    #       Cat.new.should_not eat_cheese
+    #     end
+    #   end
+    #
+    # So in the event there is no assert_does_not_eat_cheese available,
+    # you're all set!
+    def wrap_expectation(matcher, &block)
+      begin
+        block.call(matcher)
+        return true
+      rescue Exception => e
+        matcher.failure_message = e.message
+        return false
+      end
+    end
+
+  end
+end

data/lib/micronaut/expectations.rb

@@ -0,0 +1,46 @@
+require 'micronaut/matchers'
+require 'micronaut/expectations/extensions/object'
+require 'micronaut/expectations/extensions/string_and_symbol'
+require 'micronaut/expectations/handler'
+require 'micronaut/expectations/wrap_expectation'
+
+module Micronaut
+
+  # Micronaut::Expectations lets you set expectations on your objects.
+  #
+  #   result.should == 37
+  #   team.should have(11).players_on_the_field
+  #
+  # == How Expectations work.
+  #
+  # Micronaut::Expectations adds two methods to Object:
+  #
+  #   should(matcher=nil)
+  #   should_not(matcher=nil)
+  #
+  # Both methods take an optional Expression Matcher (See Micronaut::Matchers).
+  #
+  # When +should+ receives an Expression Matcher, it calls <tt>matches?(self)</tt>. If
+  # it returns +true+, the spec passes and execution continues. If it returns
+  # +false+, then the spec fails with the message returned by <tt>matcher.failure_message</tt>.
+  #
+  # Similarly, when +should_not+ receives a matcher, it calls <tt>matches?(self)</tt>. If
+  # it returns +false+, the spec passes and execution continues. If it returns
+  # +true+, then the spec fails with the message returned by <tt>matcher.negative_failure_message</tt>.
+  #
+  # Micronaut ships with a standard set of useful matchers, and writing your own
+  # matchers is quite simple. See Micronaut::Matchers for details.
+  module Expectations
+
+    class ExpectationNotMetError < ::StandardError; end
+  
+    def self.fail_with(message, expected=nil, target=nil) # :nodoc:
+      if Array === message && message.length == 3
+        message, expected, target = message[0], message[1], message[2]
+      end
+      Kernel::raise(Micronaut::Expectations::ExpectationNotMetError.new(message))
+    end
+  
+  end
+  
+end

data/lib/micronaut/formatters/base_formatter.rb

@@ -0,0 +1,82 @@
+module Micronaut
+  module Formatters
+    # Baseclass for formatters that implements all required methods as no-ops. 
+    class BaseFormatter
+      attr_accessor :behaviour, :options, :output, :total_example_failed, :total_example_pending
+      
+      def initialize(options, output_to)
+        @options, @output = options, output_to
+        @total_example_failed, @total_example_pending = 0, 0
+      end
+      
+      def profile_examples?
+        Micronaut.configuration.profile_examples
+      end
+
+      # This method is invoked before any examples are run, right after
+      # they have all been collected. This can be useful for special
+      # formatters that need to provide progress on feedback (graphical ones)
+      #
+      # This method will only be invoked once, and the next one to be invoked
+      # is #add_behaviour
+      def start(example_count)
+      end
+
+      # This method is invoked at the beginning of the execution of each behaviour.
+      # +behaviour+ is the behaviour.
+      #
+      # The next method to be invoked after this is #example_failed or #example_finished
+      def add_behaviour(behaviour)
+        @behaviour = behaviour
+      end
+
+      # This method is invoked when an +example+ starts.
+      def example_started(example)
+
+      end
+
+      # This method is invoked when an +example+ passes.
+      def example_passed(example)
+      end
+
+      # This method is invoked when an +example+ fails, i.e. an exception occurred
+      # inside it (such as a failed should or other exception). +counter+ is the 
+      # sequence number of the failure (starting at 1) and +failure+ is the associated 
+      # exception.
+      def example_failed(example, exception)
+        @total_example_failed += 1
+      end
+
+      # This method is invoked when an example is not yet implemented (i.e. has not
+      # been provided a block), or when an ExamplePendingError is raised.
+      # +message+ is the message from the ExamplePendingError, if it exists, or the
+      # default value of "Not Yet Implemented"
+      # +pending_caller+ is the file and line number of the spec which
+      # has called the pending method
+      def example_pending(example, message)
+      end
+
+      # This method is invoked after all of the examples have executed. The next method
+      # to be invoked after this one is #dump_failure (once for each failed example),
+      def start_dump
+      end
+
+      # Dumps detailed information about each example failure.
+      def dump_failures
+      end
+
+      # This method is invoked after the dumping of examples and failures.
+      def dump_summary(duration, example_count, failure_count, pending_count)
+      end
+
+      # This gets invoked after the summary if option is set to do so.
+      def dump_pending
+      end
+
+      # This method is invoked at the very end. Allows the formatter to clean up, like closing open streams.
+      def close
+      end
+    end
+    
+  end
+end

data/lib/micronaut/formatters/base_text_formatter.rb

@@ -0,0 +1,148 @@
+module Micronaut
+
+  module Formatters
+
+    class BaseTextFormatter < BaseFormatter
+      attr_reader :pending_examples, :failed_examples
+
+      def initialize(options, output_to)
+        super
+        @pending_examples = []
+        @failed_examples = []
+        @example_profiling_info = []
+      end
+            
+      def example_passed(example)
+        super
+        # Why && @start_time
+        if profile_examples? && @start_time
+          @example_profiling_info << [example, Time.now - @start_time] 
+        end
+      end
+      
+      def example_started(example)
+        @start_time = Time.now
+      end
+
+      def example_pending(example, message)
+        @pending_examples << [example, message]
+      end
+
+      def example_failed(example, exception)
+        super
+        @failed_examples << [example, exception]
+      end
+
+      def dump_failures        
+        @output.puts
+        @failed_examples.each_with_index do |examples_with_exception, index|
+          example, exception = examples_with_exception.first, examples_with_exception.last
+          @output.puts "#{index.next}) #{example}"
+          @output.puts colorise(exception.message, exception)
+          @output.puts format_backtrace(exception.backtrace)
+          @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(duration, example_count, failure_count, pending_count)
+        @output.puts "\nFinished in #{duration} seconds\n"
+
+        summary = "#{example_count} example#{'s' unless example_count == 1}, #{failure_count} failure#{'s' unless failure_count == 1}"
+        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
+        
+        if profile_examples?  
+          sorted_examples = @example_profiling_info.sort_by { |desc, time| time }
+          @output.puts "\nTop 10 slowest examples:\n"        
+          sorted_examples.last(10).reverse.each do |desc, time|
+            @output.puts "  (#{sprintf("%.7f", time)} seconds) #{desc}"
+          end
+        end
+        
+        @output.flush
+      end
+
+      def dump_pending
+        unless @pending_examples.empty?
+          @output.puts
+          @output.puts "Pending:"
+          @pending_examples.each do |pending_example, message|
+            @output.puts "\n  #{pending_example.behaviour}\n  - #{pending_example.description}"
+          end
+        end
+        @output.flush
+      end
+
+      def close
+        if IO === @output && @output != $stdout
+          @output.close 
+        end
+      end
+
+      def format_backtrace(backtrace)
+        return "" if backtrace.nil?
+        cleansed = backtrace.map { |line| backtrace_line(line) }.compact.join("\n")
+        cleansed.empty? ? backtrace : cleansed
+      end
+
+      protected
+
+      def enable_color_in_output?
+        @options.enable_color_in_output?
+      end
+
+      def backtrace_line(line)
+        return nil if Micronaut.configuration.cleaned_from_backtrace?(line)
+        line.sub!(/\A([^:]+:\d+)$/, '\\1')
+        return nil if line == '-e:1'
+        line
+      end
+
+      def color(text, color_code)
+        return text unless enable_color_in_output?
+        "#{color_code}#{text}\e[0m"
+      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
+
+    end
+    
+  end
+
+end

data/lib/micronaut/formatters/documentation_formatter.rb

@@ -0,0 +1,62 @@
+module Micronaut
+  module Formatters
+
+    class DocumentationFormatter < BaseTextFormatter
+
+      attr_reader :previous_nested_behaviours
+
+      def initialize(options, output_to)
+        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]
+            desc_or_name = (i == 0) ? nested_behaviour.name : nested_behaviour.description
+            output.puts "#{'  ' * i}#{desc_or_name}"
+          end
+        end
+        
+        @previous_nested_behaviours = described_behaviour_chain
+      end
+
+      def example_failed(example, exception)
+        super
+        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
+
+        @output.puts(expectation_not_met ? red(message) : magenta(message))
+        @output.flush
+      end
+
+      def example_passed(example)
+        output.puts green("#{current_indentation}#{example.description}")
+        output.flush
+      end
+
+      def example_pending(example, message)
+        super
+        output.puts yellow("#{current_indentation}#{example.description} (PENDING: #{message})")
+        output.flush
+      end
+
+      def current_indentation
+        '  ' * previous_nested_behaviours.length
+      end
+
+      def described_behaviour_chain
+        behaviour.ancestors
+      end
+
+    end
+    
+  end
+end