spicycode-micronaut 0.0.2

data/lib/micronaut/example_group.rb

@@ -0,0 +1,100 @@
+class Micronaut::ExampleGroup
+  include Micronaut::Matchers
+  include Micronaut::Mocking::WithMocha
+  
+  attr_reader :name, :description, :examples, :before_parts, :after_parts
+
+  def initialize(const_or_name, description=nil)
+    @name, @description = const_or_name.to_s, description
+    @examples, @before_parts, @after_parts = [], {:each => [], :all => []}, {:each => [], :all => []}
+  end
+
+  def before(type = :each, &block)
+    @before_parts[type] << block
+  end
+
+  def before_each_parts
+    @before_parts[:each]
+  end
+
+  def before_all_parts
+    @before_parts[:all]
+  end
+
+  def after(type = :each, &block)
+    @after_parts[type] << block
+  end
+
+  def after_each_parts
+    @after_parts[:each]
+  end
+
+  def after_all_parts
+    @after_parts[:all]
+  end
+
+  def it(example_description, &example_block)
+    @examples << [example_description, example_block]
+  end
+
+  def run
+    before_all_parts.each { |part| part.call }
+
+    @examples.each do |example_description, example_block| 
+
+      before_each_parts.each { |part| part.call }
+
+      example_block.call
+
+      after_each_parts.each { |part| part.call }
+
+    end
+
+    after_all_parts.each { |part| part.call }
+  end
+
+  def run_group_using(runner)
+    result = ''
+
+    begin
+      @passed = nil
+
+      before_all_parts.each { |part| part.call }
+
+      @examples.each do |example_description, example_block| 
+        
+        setup_mocks
+        
+        before_each_parts.each { |part| part.call }
+
+        if example_block.nil?
+          result << 'P'
+        else
+          example_block.call
+        end
+
+        result << '.'
+
+        after_each_parts.each { |part| part.call }
+        
+        verify_mocks
+        
+        teardown_mocks
+      end
+
+      @passed = true
+    rescue Exception => e
+      result << runner.complain(self.class, self.name, e)
+      @passed = false
+    ensure
+      begin
+        after_all_parts.each { |part| part.call }
+      rescue Exception => e
+        result << runner.complain(self.class, self.name, e)
+      end
+    end
+
+    result
+  end
+
+end

data/lib/micronaut/example_runner.rb

@@ -0,0 +1,108 @@
+module Micronaut
+  class ExampleRunner
+
+    attr_accessor :report, :failures, :errors
+    attr_accessor :example_count
+
+    @@installed_at_exit ||= false
+    @@out = $stdout
+
+    def initialize
+      @report = []
+      @errors, @failures = 0, 0
+      @verbose = false
+    end
+
+    def self.autorun
+      at_exit {
+        exit_code = Micronaut::ExampleRunner.new.run(ARGV)
+        exit false if exit_code && exit_code != 0
+      } unless @@installed_at_exit
+      @@installed_at_exit = true
+    end
+
+    def self.output=(stream)
+      @@out = stream
+    end
+    
+    def location(e)
+      e.backtrace.find { |s|
+        s !~ /in .(assert|refute|flunk|pass|fail|raise)/
+      }.sub(/:in .*$/, '')
+    end
+
+    def complain(cls, method_in_question, e)
+      bt = Micronaut::filter_backtrace(e.backtrace).join("\n    ")
+      
+      e = case e.class.to_s
+          when 'Micronaut::Exceptions::ExpectationNotMetError', 'Mocha::ExpectationError' then
+            @failures += 1
+            "Failure:\n#{method_in_question}(#{cls}) [#{location(e)}]:\n#{e.message}\n    #{bt}\n"
+          else
+            puts e.to_s
+            @errors += 1
+            "Error:\n#{method_in_question}(#{cls}):\n#{e.class}: #{e.message}\n    #{bt}\n"
+          end
+      @report << e
+      e[0, 1]
+    end
+
+    ##
+    # Top level driver, controls all output and filtering.
+    def run(args = [])
+      @verbose = args.delete('-v')
+
+      filter = if args.first =~ /^(-n|--name)$/ then
+                 args.shift
+                 arg = args.shift
+                 arg =~ /\/(.*)\// ? Regexp.new($1) : arg
+               else
+                 /./ # anything - ^example_ already filtered by #examples
+               end
+
+      @@out.puts "Loading examples from #{$0}\nStarted"
+
+      start = Time.now
+      run_examples filter
+
+      @@out.puts
+      @@out.puts "Finished in #{'%.6f' % (Time.now - start)} seconds."
+
+      @report.each_with_index do |msg, i|
+        @@out.puts "\n%3d) %s" % [i + 1, msg]
+      end
+
+      @@out.puts
+
+      format = "%d examples, %d failures, %d errors"
+      @@out.puts format % [example_count, failures, errors]
+
+      return failures + errors if @example_count > 0 # or return nil...
+    end
+
+    def run_examples(filter = /./)
+      @example_count = 0
+      old_sync, @@out.sync = @@out.sync, true if @@out.respond_to?(:sync=)
+      
+      Micronaut::ExampleWorld.example_groups.each do |example_group|
+        # example_group.examples.grep(filter).each do |test|
+        # example_group.examples.each do |example|
+          @@out.print "#{example_group.name}: " if @verbose
+
+          t = Time.now if @verbose
+          result = example_group.run_group_using(self)
+
+          @example_count += example_group.examples.size
+          
+          @@out.print "%.6fs: " % (Time.now - t) if @verbose
+          @@out.print result
+          @@out.puts if @verbose
+        # end
+      end
+      
+      @@out.sync = old_sync if @@out.respond_to? :sync=
+      @example_count
+    end
+    
+  end
+end

data/lib/micronaut/example_world.rb

@@ -0,0 +1,13 @@
+class Micronaut::ExampleWorld
+  
+  def self.reset
+    @@example_groups = []
+  end
+
+  reset
+  
+  def self.example_groups
+    @@example_groups
+  end
+  
+end

data/lib/micronaut/exceptions.rb

@@ -0,0 +1,7 @@
+module Micronaut
+  class Exceptions
+   
+    class ExpectationNotMetError < ::StandardError; end
+        
+  end
+end

data/lib/micronaut/expectations/differs/default.rb

@@ -0,0 +1,67 @@
+begin
+  require 'rubygems'
+  require 'diff/lcs' #necessary due to loading bug on some machines - not sure why - DaC
+  require 'diff/lcs/hunk'
+rescue LoadError ; raise "You must gem install diff-lcs to use diffing" ; end
+
+require 'pp'
+
+module Micronaut
+  module Expectations
+    module Differs
+
+      # TODO add some rdoc
+      class Default
+        def initialize(diff_type = :unified, context_lines = 3)
+          @format = diff_type
+          @context_lines = context_lines
+        end
+
+        # This is snagged from diff/lcs/ldiff.rb (which is a commandline tool)
+        def diff_as_string(data_new, data_old)
+          data_old = data_old.split(/\n/).map! { |e| e.chomp }
+          data_new = data_new.split(/\n/).map! { |e| e.chomp }
+          output = ""
+          diffs = Diff::LCS.diff(data_old, data_new)
+          return output if diffs.empty?
+          oldhunk = hunk = nil  
+          file_length_difference = 0
+          diffs.each do |piece|
+            begin
+              hunk = Diff::LCS::Hunk.new(data_old, data_new, piece, context_lines,
+                                         file_length_difference)
+              file_length_difference = hunk.file_length_difference      
+              next unless oldhunk      
+              # Hunks may overlap, which is why we need to be careful when our
+              # diff includes lines of context. Otherwise, we might print
+              # redundant lines.
+              if (context_lines > 0) and hunk.overlaps?(oldhunk)
+                hunk.unshift(oldhunk)
+              else
+                output << oldhunk.diff(format)
+              end
+            ensure
+              oldhunk = hunk
+              output << "\n"
+            end
+          end  
+          #Handle the last remaining hunk
+          output << oldhunk.diff(format) << "\n"
+        end  
+
+        def diff_as_object(target,expected)
+          diff_as_string(PP.pp(target,""), PP.pp(expected,""))
+        end
+
+        protected
+        def format
+          @format
+        end
+
+        def context_lines
+          @context_lines
+        end
+      end
+    end
+  end
+end

data/lib/micronaut/expectations/handler.rb

@@ -0,0 +1,52 @@
+module Micronaut
+  module Expectations
+    class InvalidMatcherError < ArgumentError; end        
+    
+    class ExpectationMatcherHandler        
+      class << self
+        def 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
+    end
+
+    class NegativeExpectationMatcherHandler
+      class << self
+        def 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
+end
+

data/lib/micronaut/expectations/object_extensions.rb

@@ -0,0 +1,62 @@
+module Micronaut
+  module Expectations
+    # We add #should and #should_not to every Object (and, implicitly, every Class).
+    module ObjectExtensions
+      # :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::ObjectExtensions
+end

data/lib/micronaut/expectations/string_and_symbol_extensions.rb

@@ -0,0 +1,17 @@
+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/wrap_expectation.rb

@@ -0,0 +1,51 @@
+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).
+    #     
+    # == 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,57 @@
+require 'micronaut/matchers'
+require 'micronaut/expectations/object_extensions'
+require 'micronaut/expectations/string_and_symbol_extensions'
+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 << self
+      attr_accessor :differ
+
+      # raises a Micronaut::Exceptions::ExpectationNotMetError with message
+      #
+      # When a differ has been assigned and fail_with is passed
+      # <code>expected</code> and <code>target</code>, passes them
+      # to the differ to append a diff message to the failure message.
+      def fail_with(message, expected=nil, target=nil) # :nodoc:
+        if Array === message && message.length == 3
+          message, expected, target = message[0], message[1], message[2]
+        end
+        unless (differ.nil? || expected.nil? || target.nil?)
+          if expected.is_a?(String)
+            message << "\nDiff:" << self.differ.diff_as_string(target.to_s, expected)
+          elsif !target.is_a?(Proc)
+            message << "\nDiff:" << self.differ.diff_as_object(target, expected)
+          end
+        end
+        Kernel::raise(Micronaut::Exceptions::ExpectationNotMetError.new(message))
+      end
+    end
+  end
+end

data/lib/micronaut/extensions/kernel.rb

@@ -0,0 +1,15 @@
+module Micronaut
+  module Extensions
+    module Kernel
+
+      def describe(name_or_const, desc=nil, &describe_block)
+        example_group = Micronaut::ExampleGroup.new(name_or_const, desc)
+        example_group.instance_eval(&describe_block)
+        Micronaut::ExampleWorld.example_groups << example_group
+      end
+
+    end
+  end
+end
+
+include Micronaut::Extensions::Kernel