mspec 1.5.10 → 1.5.11

data/Rakefile

@@ -18,7 +18,7 @@ spec = Gem::Specification.new do |s|
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors                   = ["Brian Ford"]
-  s.date                      = %q{2009-3-1}
+  s.date                      = %q{2009-3-30}
   s.email                     = %q{bford@engineyard.com}
   s.has_rdoc                  = true
   s.extra_rdoc_files          = %w[ README LICENSE ]

data/lib/mspec/commands/mkspec.rb

@@ -116,7 +116,7 @@ EOS
       methods.each { |method| create_file dir, name, method, mod + method }
     end
   end
-  
+
   ##
   # Determine and return the path of the ruby executable.
 

data/lib/mspec/expectations/expectations.rb

@@ -1,17 +1,17 @@
-class ExpectationNotMetError < StandardError; end
-class ExpectationNotFoundError < StandardError
+class SpecExpectationNotMetError < StandardError; end
+class SpecExpectationNotFoundError < StandardError
   def message
     "No behavior expectation was found in the example"
   end
 end
 
-class Expectation
+class SpecExpectation
   def self.fail_with(expected, actual)
     if expected.to_s.size + actual.to_s.size > 80
       message = expected.to_s.chomp + "\n" + actual.to_s
     else
       message = expected.to_s + " " + actual.to_s
     end
-    Kernel.raise ExpectationNotMetError, message
+    Kernel.raise SpecExpectationNotMetError, message
   end
 end

data/lib/mspec/expectations/should.rb

@@ -4,10 +4,10 @@ class Object
     MSpec.actions :expectation, MSpec.current.state
     if matcher
       unless matcher.matches?(self)
-        Expectation.fail_with(*matcher.failure_message)
+        SpecExpectation.fail_with(*matcher.failure_message)
       end
     else
-      PositiveOperatorMatcher.new(self)
+      SpecPositiveOperatorMatcher.new(self)
     end
   end
 
@@ -16,10 +16,10 @@ class Object
     MSpec.actions :expectation, MSpec.current.state
     if matcher
       if matcher.matches?(self)
-        Expectation.fail_with(*matcher.negative_failure_message)
+        SpecExpectation.fail_with(*matcher.negative_failure_message)
       end
     else
-      NegativeOperatorMatcher.new(self)
+      SpecNegativeOperatorMatcher.new(self)
     end
   end
 end

data/lib/mspec/guards/endian.rb

@@ -3,23 +3,20 @@ require 'mspec/guards/guard'
 # Despite that these are inverses, the two classes are
 # used to simplify MSpec guard reporting modes
 
-class BigEndianGuard < SpecGuard
+class EndianGuard < SpecGuard
   def pattern
-    [1].pack('L')
+    @pattern ||= [1].pack('L')
   end
   private :pattern
+end
 
+class BigEndianGuard < EndianGuard
   def match?
     pattern[-1] == ?\001
   end
 end
 
-class LittleEndianGuard < SpecGuard
-  def pattern
-    [1].pack('L')
-  end
-  private :pattern
-
+class LittleEndianGuard < EndianGuard
   def match?
     pattern[-1] == ?\000
   end

data/lib/mspec/guards/guard.rb

@@ -16,7 +16,7 @@ class SpecGuard
       size = desc.size
       spec = size == 1 ? "spec" : "specs"
       print "\n\n#{size} #{spec} omitted by guard: #{key}:\n"
-      desc.each { |desc| print "\n", desc }
+      desc.each { |description| print "\n", description; }
     end
 
     print "\n\n"

data/lib/mspec/helpers/const_lookup.rb

@@ -3,7 +3,8 @@ module Kernel
     names = c.split '::'
     names.shift if names.first.empty?
     names.inject(Object) do |m, n|
-      m.const_defined?(n) ? m.const_get(n) : m.const_missing(n)
+      defined = RUBY_VERSION =~ /^1.9/ ? m.const_defined?(n, false) : m.const_defined?(n)
+      defined ? m.const_get(n) : m.const_missing(n)
     end
   end
 end

data/lib/mspec/helpers/flunk.rb

@@ -1,5 +1,5 @@
 class Object
   def flunk(msg="This example is a failure")
-    Expectation.fail_with "Failed:", msg
+    SpecExpectation.fail_with "Failed:", msg
   end
 end

data/lib/mspec/helpers/io.rb

@@ -1,10 +1,10 @@
 class IOStub < String
   def write(*str)
-    self << str.to_s
+    self << str.join
   end
 
   def print(*str)
-    write(str.to_s + $\.to_s)
+    write(str.join + $\.to_s)
   end
 
   def puts(*str)

data/lib/mspec/helpers/ruby_exe.rb

@@ -106,9 +106,12 @@ class Object
 
   def ruby_exe(code, opts = {})
     body = code
-    body = "-e #{code.inspect}" if code and not File.exists?(code)
-    cmd = [RUBY_EXE, ENV['RUBY_FLAGS'], opts[:options], body, opts[:args]]
-    `#{cmd.compact.join(' ')}`
+    working_dir = opts[:dir] || "."
+    Dir.chdir(working_dir) do
+      body = "-e #{code.inspect}" if code and not File.exists?(code)
+      cmd = [RUBY_EXE, ENV['RUBY_FLAGS'], opts[:options], body, opts[:args]]
+      `#{cmd.compact.join(' ')}`
+    end
   end
 
   unless Object.const_defined?(:RUBY_EXE) and RUBY_EXE

data/lib/mspec/matchers/base.rb

@@ -1,94 +1,94 @@
-class PositiveOperatorMatcher
+class SpecPositiveOperatorMatcher
   def initialize(actual)
     @actual = actual
   end
 
   def ==(expected)
     unless @actual == expected
-      Expectation.fail_with("Expected #{@actual.pretty_inspect}",
+      SpecExpectation.fail_with("Expected #{@actual.pretty_inspect}",
                             "to equal #{expected.pretty_inspect}")
     end
   end
 
   def <(expected)
     unless @actual < expected
-      Expectation.fail_with("Expected #{@actual.pretty_inspect}",
+      SpecExpectation.fail_with("Expected #{@actual.pretty_inspect}",
                             "to be less than #{expected.pretty_inspect}")
     end
   end
 
   def <=(expected)
     unless @actual <= expected
-      Expectation.fail_with("Expected #{@actual.pretty_inspect}",
+      SpecExpectation.fail_with("Expected #{@actual.pretty_inspect}",
                             "to be less than or equal to #{expected.pretty_inspect}")
     end
   end
 
   def >(expected)
     unless @actual > expected
-      Expectation.fail_with("Expected #{@actual.pretty_inspect}",
+      SpecExpectation.fail_with("Expected #{@actual.pretty_inspect}",
                             "to be greater than #{expected.pretty_inspect}")
     end
   end
 
   def >=(expected)
     unless @actual >= expected
-      Expectation.fail_with("Expected #{@actual.pretty_inspect}",
+      SpecExpectation.fail_with("Expected #{@actual.pretty_inspect}",
                             "to be greater than or equal to #{expected.pretty_inspect}")
     end
   end
 
   def =~(expected)
     unless @actual =~ expected
-      Expectation.fail_with("Expected #{@actual.pretty_inspect}",
+      SpecExpectation.fail_with("Expected #{@actual.pretty_inspect}",
                             "to match #{expected.pretty_inspect}")
     end
   end
 end
 
-class NegativeOperatorMatcher
+class SpecNegativeOperatorMatcher
   def initialize(actual)
     @actual = actual
   end
 
   def ==(expected)
     if @actual == expected
-      Expectation.fail_with("Expected #{@actual.pretty_inspect}",
+      SpecExpectation.fail_with("Expected #{@actual.pretty_inspect}",
                             "not to equal #{expected.pretty_inspect}")
     end
   end
 
   def <(expected)
     if @actual < expected
-      Expectation.fail_with("Expected #{@actual.pretty_inspect}",
+      SpecExpectation.fail_with("Expected #{@actual.pretty_inspect}",
                             "not to be less than #{expected.pretty_inspect}")
     end
   end
 
   def <=(expected)
     if @actual <= expected
-      Expectation.fail_with("Expected #{@actual.pretty_inspect}",
+      SpecExpectation.fail_with("Expected #{@actual.pretty_inspect}",
                             "not to be less than or equal to #{expected.pretty_inspect}")
     end
   end
 
   def >(expected)
     if @actual > expected
-      Expectation.fail_with("Expected #{@actual.pretty_inspect}",
+      SpecExpectation.fail_with("Expected #{@actual.pretty_inspect}",
                             "not to be greater than #{expected.pretty_inspect}")
     end
   end
 
   def >=(expected)
     if @actual >= expected
-      Expectation.fail_with("Expected #{@actual.pretty_inspect}",
+      SpecExpectation.fail_with("Expected #{@actual.pretty_inspect}",
                             "not to be greater than or equal to #{expected.pretty_inspect}")
     end
   end
 
   def =~(expected)
     if @actual =~ expected
-      Expectation.fail_with("Expected #{@actual.pretty_inspect}",
+      SpecExpectation.fail_with("Expected #{@actual.pretty_inspect}",
                             "not to match #{expected.pretty_inspect}")
     end
   end

data/lib/mspec/matchers/be_an_instance_of.rb

@@ -0,0 +1,26 @@
+class BeAnInstanceOfMatcher
+  def initialize(expected)
+    @expected = expected
+  end
+
+  def matches?(actual)
+    @actual = actual
+    @actual.instance_of?(@expected)
+  end
+
+  def failure_message
+    ["Expected #{@actual.inspect} (#{@actual.class})",
+     "to be an instance of #{@expected}"]
+  end
+
+  def negative_failure_message
+    ["Expected #{@actual.inspect} (#{@actual.class})",
+     "not to be an instance of #{@expected}"]
+  end
+end
+
+class Object
+  def be_an_instance_of(expected)
+    BeAnInstanceOfMatcher.new(expected)
+  end
+end

data/lib/mspec/mocks/mock.rb

@@ -77,7 +77,7 @@ module Mock
           false
         end
         unless pass
-          Expectation.fail_with(
+          SpecExpectation.fail_with(
             "Mock '#{name_or_inspect obj}' expected to receive '#{sym}' " \
             "#{qualifier.to_s.sub('_', ' ')} #{count} times",
             "but received it #{proxy.calls} times")
@@ -110,14 +110,14 @@ module Mock
             if block.arity == -1 || block.arity == args_to_yield.size
               block.call(*args_to_yield)
             else
-              Expectation.fail_with(
+              SpecExpectation.fail_with(
                 "Mock '#{name_or_inspect obj}' asked to yield " \
                 "|#{proxy.yielding.join(', ')}| on #{sym}\n",
                 "but a block with arity #{block.arity} was passed")
             end
           end
         else
-          Expectation.fail_with(
+          SpecExpectation.fail_with(
             "Mock '#{name_or_inspect obj}' asked to yield " \
             "|[#{proxy.yielding.join('], [')}]| on #{sym}\n",
             "but no block was passed")
@@ -133,7 +133,7 @@ module Mock
     if sym.to_sym == :respond_to?
       return obj.__send__(replaced_name(obj, sym), compare)
     else
-      Expectation.fail_with("Mock '#{name_or_inspect obj}': method #{sym}\n",
+      SpecExpectation.fail_with("Mock '#{name_or_inspect obj}': method #{sym}\n",
                             "called with unexpected arguments (#{Array(compare).join(' ')})")
     end
   end
@@ -143,7 +143,7 @@ module Mock
     symbols.uniq.each do |replaced, obj, sym|
       meta = class << obj; self; end
 
-      if meta.instance_methods.include?(replaced.to_s)
+      if meta.instance_methods.map { |x| x.to_sym }.include?(replaced.to_sym)
         meta.__send__ :alias_method, sym.to_sym, replaced
         meta.__send__ :remove_method, replaced
       else

data/lib/mspec/runner/context.rb

@@ -34,7 +34,7 @@ class ContextState
 
     @mock_verify         = lambda { Mock.verify_count }
     @mock_cleanup        = lambda { Mock.cleanup }
-    @expectation_missing = lambda { raise ExpectationNotFoundError }
+    @expectation_missing = lambda { raise SpecExpectationNotFoundError }
   end
 
   # Returns true if this is a shared +ContextState+. Essentially, when

data/lib/mspec/runner/exception.rb

@@ -18,14 +18,14 @@ class ExceptionState
   end
 
   def failure?
-    [ExpectationNotMetError, ExpectationNotFoundError].any? { |e| @exception.is_a? e }
+    [SpecExpectationNotMetError, SpecExpectationNotFoundError].any? { |e| @exception.is_a? e }
   end
 
   def message
     if @exception.message.empty?
       "<No message>"
-    elsif @exception.class == ExpectationNotMetError ||
-          @exception.class == ExpectationNotFoundError
+    elsif @exception.class == SpecExpectationNotMetError ||
+          @exception.class == SpecExpectationNotFoundError
       @exception.message
     else
       "#{@exception.class}: #{@exception.message}"

data/lib/mspec/runner/formatters/dotted.rb

@@ -65,8 +65,8 @@ class DottedFormatter
   # Callback for the MSpec :after event. Prints an indicator
   # for the result of evaluating this example as follows:
   #   . = No failure or error
-  #   F = An ExpectationNotMetError was raised
-  #   E = Any exception other than ExpectationNotMetError
+  #   F = An SpecExpectationNotMetError was raised
+  #   E = Any exception other than SpecExpectationNotMetError
   def after(state = nil)
     unless exception?
       print "."

data/lib/mspec/utils/name_map.rb

@@ -96,11 +96,12 @@ class NameMap
       next unless m and not @seen[m]
       @seen[m] = true
 
-      ms = m.methods false
+      ms = m.methods(false).map { |x| x.to_s }
       hash["#{name}."] = ms.sort unless ms.empty?
 
       ms = m.public_instance_methods(false) +
            m.protected_instance_methods(false)
+      ms.map! { |x| x.to_s }
       hash["#{name}#"] = ms.sort unless ms.empty?
 
       map hash, m.constants, name

data/lib/mspec/utils/options.rb

@@ -102,8 +102,10 @@ class MSpecOptions
       if option.arg?
         arg = argv.shift if arg.nil?
         raise ParseError, "No argument provided for #{opt}" unless arg
+        option.block[arg] if option.block
+      else
+        option.block[] if option.block
       end
-      option.block[arg] if option.block
     end
     option
   end

data/lib/mspec/utils/script.rb

@@ -171,9 +171,10 @@ class MSpecScript
 
     patterns.each do |pattern|
       expanded = File.expand_path(pattern)
-      return [pattern] if File.file?(expanded)
+      return [expanded] if File.file?(expanded)
 
-      specs = File.join pattern, "/**/*_spec.rb"
+      specs = File.join(pattern, "/**/*_spec.rb")
+      specs = File.expand_path(specs) rescue specs
       return Dir[specs].sort if File.directory?(expanded)
     end
 

data/lib/mspec/version.rb

@@ -1,5 +1,5 @@
 require 'mspec/utils/version'
 
 module MSpec
-  VERSION = SpecVersion.new "1.5.10"
+  VERSION = SpecVersion.new "1.5.11"
 end

data/spec/commands/mkspec_spec.rb

@@ -297,7 +297,8 @@ describe MkSpec, "#run" do
   end
 
   it "calls #create_file for each method on each class/module in the map" do
-    @map.should_receive(:map).with({}, @script.config[:constants]).and_return({"MkSpec#" => "run"})
+    @map.should_receive(:map).with({}, @script.config[:constants]
+                                  ).and_return({"MkSpec#" => ["run"]})
     @script.should_receive(:create_file).with("spec/mkspec", "MkSpec", "run", "MkSpec#run")
     @script.run
   end

data/spec/expectations/expectations_spec.rb

@@ -1,29 +1,29 @@
 require File.dirname(__FILE__) + '/../spec_helper'
 require 'mspec/expectations/expectations'
 
-describe ExpectationNotMetError do
+describe SpecExpectationNotMetError do
   it "is a subclass of StandardError" do
-    ExpectationNotMetError.ancestors.should include(StandardError)
+    SpecExpectationNotMetError.ancestors.should include(StandardError)
   end
 end
 
-describe ExpectationNotFoundError do
+describe SpecExpectationNotFoundError do
   it "is a subclass of StandardError" do
-    ExpectationNotFoundError.ancestors.should include(StandardError)
+    SpecExpectationNotFoundError.ancestors.should include(StandardError)
   end
 end
 
-describe ExpectationNotFoundError, "#message" do
+describe SpecExpectationNotFoundError, "#message" do
   it "returns 'No behavior expectation was found in the example'" do
-    m = ExpectationNotFoundError.new.message
+    m = SpecExpectationNotFoundError.new.message
     m.should == "No behavior expectation was found in the example"
   end
 end
 
-describe Expectation, "#fail_with" do
-  it "raises an ExpectationNotMetError" do
+describe SpecExpectation, "#fail_with" do
+  it "raises an SpecExpectationNotMetError" do
     lambda {
-      Expectation.fail_with "expected this", "to equal that"
-    }.should raise_error(ExpectationNotMetError, "expected this to equal that")
+      SpecExpectation.fail_with "expected this", "to equal that"
+    }.should raise_error(SpecExpectationNotMetError, "expected this to equal that")
   end
 end