mspec 1.0.0 → 1.1.0

data/Rakefile

@@ -9,7 +9,7 @@ task :default => :spec
 
 spec = Gem::Specification.new do |s|
   s.name                      = %q{mspec}
-  s.version                   = "1.0.0"
+  s.version                   = "1.1.0"
 
   s.specification_version     = 2 if s.respond_to? :specification_version=
 
@@ -25,20 +25,20 @@ spec = Gem::Specification.new do |s|
   s.rubyforge_project         = 'http://rubyforge.org/projects/mspec'
   s.require_paths             = ["lib"]
   s.rubygems_version          = %q{1.1.1}
-  s.summary                   = <<EOS 
-MSpec is a specialized framework that is syntax-compatible 
-with RSpec for basic things like describe, it blocks and 
+  s.summary                   = <<EOS
+MSpec is a specialized framework that is syntax-compatible
+with RSpec for basic things like describe, it blocks and
 before, after actions.
 
-MSpec contains additional features that assist in writing 
-the RubySpecs used by multiple Ruby implementations. Also, 
-MSpec attempts to use the simplest Ruby language features 
+MSpec contains additional features that assist in writing
+the RubySpecs used by multiple Ruby implementations. Also,
+MSpec attempts to use the simplest Ruby language features
 so that beginning Ruby implementations can run it.
 EOS
-  
+
   s.rdoc_options << '--title' << 'MSpec Gem' <<
                    '--main' << 'README' <<
                    '--line-numbers'
 end
 
-Rake::GemPackageTask.new(spec){ |pkg| pkg.gem_spec = spec }
+Rake::GemPackageTask.new(spec){ |pkg| pkg.gem_spec = spec }

data/lib/mspec.rb

@@ -4,3 +4,8 @@ require 'mspec/mocks'
 require 'mspec/runner'
 require 'mspec/guards'
 require 'mspec/helpers'
+
+# If the implementation on which the specs are run cannot
+# load pp from the standard library, add a pp.rb file that
+# defines the #pretty_inspect method on Object or Kernel.
+require 'pp'

data/lib/mspec/commands/mspec-ci.rb

@@ -20,7 +20,6 @@ class MSpecCI < MSpecScript
     options.separator "\n How to run the specs"
     options.add_config { |f| load f }
     options.add_name
-    options.add_tags_dir
     options.add_pretend
     options.add_interrupt
 
@@ -59,7 +58,7 @@ class MSpecCI < MSpecScript
       files.concat(Dir[item+"/**/*_spec.rb"].sort) if stat.directory?
     end
 
-    MSpec.register_tags_path config[:tags_dir]
+    MSpec.register_tags_patterns config[:tags_patterns]
     MSpec.register_files files
     TagFilter.new(:exclude, "fails").register
     TagFilter.new(:exclude, "unstable").register

data/lib/mspec/commands/mspec-run.rb

@@ -24,7 +24,6 @@ class MSpecRun < MSpecScript
     options.separator "\n How to modify the execution"
     options.add_config { |f| load f }
     options.add_name
-    options.add_tags_dir
     options.add_randomize
     options.add_pretend
     options.add_interrupt
@@ -70,7 +69,7 @@ class MSpecRun < MSpecScript
       files.concat(Dir[item+"/**/*_spec.rb"].sort) if stat.directory?
     end
 
-    MSpec.register_tags_path config[:tags_dir]
+    MSpec.register_tags_patterns config[:tags_patterns]
     MSpec.register_files files
 
     MSpec.process

data/lib/mspec/commands/mspec-tag.rb

@@ -30,7 +30,6 @@ class MSpecTag < MSpecScript
     options.separator "\n How to modify the execution"
     options.add_config { |f| load f }
     options.add_name
-    options.add_tags_dir
     options.add_pretend
     options.add_interrupt
 
@@ -77,7 +76,7 @@ class MSpecTag < MSpecScript
       files.concat(Dir[item+"/**/*_spec.rb"].sort) if stat.directory?
     end
 
-    MSpec.register_tags_path config[:tags_dir]
+    MSpec.register_tags_patterns config[:tags_patterns]
     MSpec.register_files files
 
     MSpec.process

data/lib/mspec/helpers/const_lookup.rb

@@ -1,5 +1,9 @@
 module Kernel
   def const_lookup(c)
-    c.split('::').inject(Object) { |k,n| k.const_get n }
+    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)
+    end
   end
 end

data/lib/mspec/matchers.rb

@@ -9,6 +9,7 @@ require 'mspec/matchers/be_true'
 require 'mspec/matchers/equal'
 require 'mspec/matchers/eql'
 require 'mspec/matchers/include'
+require 'mspec/matchers/match_yaml'
 require 'mspec/matchers/raise_error'
 require 'mspec/matchers/output'
 require 'mspec/matchers/output_to_fd'

data/lib/mspec/matchers/match_yaml.rb

@@ -0,0 +1,47 @@
+class MatchYAMLMatcher
+
+  def initialize(expected)
+    if valid_yaml?(expected)
+      @expected = expected
+    else
+      @expected = expected.to_yaml
+    end
+  end
+
+  def matches?(actual)
+    @actual = actual    
+    clean_yaml(@actual) == @expected
+  end
+
+  def failure_message
+    ["Expected #{@actual.inspect}", " to match #{@expected.inspect}"]
+  end
+
+  def negative_failure_message
+    ["Expected #{@actual.inspect}", " to match #{@expected.inspect}"]
+  end
+  
+  protected
+  
+  def clean_yaml(yaml)
+    yaml.gsub(/([^-])\s+\n/, "\\1\n")
+  end
+
+  def valid_yaml?(obj)
+    require 'yaml'
+    begin
+      YAML.load(obj)
+    rescue
+      false
+    else
+      true
+    end
+  end
+end
+
+class Object
+  def match_yaml(expected)
+    MatchYAMLMatcher.new(expected)
+  end
+end
+

data/lib/mspec/mocks/mock.rb

@@ -2,22 +2,35 @@ require 'mspec/expectations/expectations'
 
 module Mock
   def self.reset
-    @expects = nil
+    @mocks = @stubs = nil
   end
 
-  def self.expects
-    @expects ||= Hash.new { |h,k| h[k] = [] }
+  def self.mocks
+    @mocks ||= Hash.new { |h,k| h[k] = [] }
   end
 
-  def self.replaced_name(sym)
-    :"__ms_#{sym}__"
+  def self.stubs
+    @stubs ||= Hash.new { |h,k| h[k] = [] }
   end
 
-  def self.install_method(obj, sym, type = :mock)
+  def self.replaced_name(obj, sym)
+    :"__ms_#{obj.__id__}_#{sym}__"
+  end
+
+  def self.replaced_key(obj, sym)
+    [replaced_name(obj, sym), obj, sym]
+  end
+
+  def self.replaced?(key)
+    !!(mocks.keys + stubs.keys).find { |k| k.first == key.first }
+  end
+
+  def self.install_method(obj, sym, type=nil)
     meta = class << obj; self; end
 
-    if (sym.to_sym == :respond_to? or obj.respond_to?(sym)) and !meta.instance_methods.include?(replaced_name(sym).to_s)
-      meta.__send__ :alias_method, replaced_name(sym), sym.to_sym
+    key = replaced_key obj, sym
+    if (sym.to_sym == :respond_to? or obj.respond_to?(sym)) and !replaced?(key)
+      meta.__send__ :alias_method, key.first, sym.to_sym
     end
 
     meta.class_eval <<-END
@@ -26,23 +39,26 @@ module Mock
       end
     END
 
-    MSpec.actions :expectation, MSpec.current.state
+    proxy = MockProxy.new type
 
-    proxy = MockProxy.new
+    MSpec.actions :expectation, MSpec.current.state if proxy.mock?
 
-    if type == :stub
-      expects[[obj, sym]] << proxy
-      proxy.at_least(0)
+    if proxy.stub?
+      stubs[key].unshift proxy
     else
-      expects[[obj, sym]].unshift proxy
-      proxy.exactly(1)
+      mocks[key] << proxy
     end
+
+    proxy
   end
 
-  def self.verify_count
-    expects.each do |key, proxies|
-      obj, sym = key.first, key.last
+  def self.name_or_inspect(obj)
+    obj.instance_variable_get(:@name) || obj.inspect
+  end
 
+  def self.verify_count
+    mocks.each do |key, proxies|
+      replaced, obj, sym = *key
       proxies.each do |proxy|
         qualifier, count = proxy.count
         pass = case qualifier
@@ -52,12 +68,16 @@ module Mock
           proxy.calls <= count
         when :exactly
           proxy.calls == count
+        when :any_number_of_times
+          true
         else
           false
         end
         unless pass
-          Expectation.fail_with("Mock #{obj.inspect}\nexpected to receive #{sym} #{qualifier.to_s.sub('_', ' ')} #{count} times",
-                                "but received it #{proxy.calls} times")
+          Expectation.fail_with(
+            "Mock '#{name_or_inspect obj}' expected to receive '#{sym}' " \
+            "#{qualifier.to_s.sub('_', ' ')} #{count} times",
+            "but received it #{proxy.calls} times")
         end
       end
     end
@@ -66,7 +86,9 @@ module Mock
   def self.verify_call(obj, sym, *args, &block)
     compare = *args
 
-    expects[[obj, sym]].each do |proxy|
+    key = replaced_key obj, sym
+    proxies = mocks[key] + stubs[key]
+    proxies.each do |proxy|
       pass = case proxy.arguments
       when :any_args
         true
@@ -75,20 +97,24 @@ module Mock
       else
         proxy.arguments == compare
       end
-      
+
       if proxy.yielding?
         if block
           proxy.yielding.each do |args_to_yield|
             if block.arity == -1 || block.arity == args_to_yield.size
               block.call(*args_to_yield)
             else
-              Expectation.fail_with("Mock #{obj.inspect} asked to yield |#{proxy.yielding.join(', ')}| on #{sym}\n",
-                                    "but a block with arity #{block.arity} was passed")
+              Expectation.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("Mock #{obj.inspect} asked to yield |[#{proxy.yielding.join('], [')}]| on #{sym}\n",
-                                "but no block was passed")
+          Expectation.fail_with(
+            "Mock '#{name_or_inspect obj}' asked to yield " \
+            "|[#{proxy.yielding.join('], [')}]| on #{sym}\n",
+            "but no block was passed")
         end
       end
 
@@ -99,18 +125,18 @@ module Mock
     end
 
     if sym.to_sym == :respond_to?
-      return obj.__send__(replaced_name(sym), compare)
+      return obj.__send__(replaced_name(obj, sym), compare)
     else
-      Expectation.fail_with("Mock #{obj.inspect}: method #{sym}\n",
+      Expectation.fail_with("Mock '#{name_or_inspect obj}': method #{sym}\n",
                             "called with unexpected arguments (#{Array(compare).join(' ')})")
     end
   end
 
   def self.cleanup
-    expects.keys.each do |obj, sym|
+    symbols = mocks.keys + stubs.keys
+    symbols.uniq.each do |replaced, obj, sym|
       meta = class << obj; self; end
 
-      replaced = replaced_name(sym)
       if meta.instance_methods.include?(replaced.to_s)
         meta.__send__ :alias_method, sym.to_sym, replaced
         meta.__send__ :remove_method, replaced

data/lib/mspec/mocks/object.rb

@@ -1,16 +1,10 @@
 require 'mspec/mocks/proxy'
 
-class MockObject
-  def initialize(name)
-    @name = name
-  end
-end
-
 class Object
   def stub!(sym)
     Mock.install_method self, sym, :stub
   end
-  
+
   def should_receive(sym)
     Mock.install_method self, sym
   end
@@ -18,11 +12,9 @@ class Object
   def should_not_receive(sym)
     proxy = Mock.install_method self, sym
     proxy.exactly(0).times
-    # return nil so that further chained calls will raise
-    nil
   end
 
-  def mock(name)
-    MockObject.new(name)
+  def mock(name, options={})
+    MockObject.new name, options
   end
 end

data/lib/mspec/mocks/proxy.rb

@@ -1,13 +1,33 @@
+class MockObject
+  def initialize(name, options={})
+    @name = name
+    @null = options[:null_object]
+  end
+
+  def method_missing(sym, *args, &block)
+    @null ? self : super
+  end
+end
+
 class MockProxy
-  def initialize
+  def initialize(type=nil)
     @multiple_returns = nil
     @returning = nil
     @yielding  = []
     @arguments = :any_args
+    @type      = type || :mock
+  end
+
+  def mock?
+    @type == :mock
+  end
+
+  def stub?
+    @type == :stub
   end
 
   def count
-    @count ||= [:exactly, 0]
+    @count ||= mock? ? [:exactly, 1] : [:any_number_of_times, 0]
   end
 
   def arguments
@@ -61,7 +81,8 @@ class MockProxy
   end
 
   def any_number_of_times
-    at_least 0
+    @count = [:any_number_of_times, 0]
+    self
   end
 
   def with(*args)

data/lib/mspec/runner/mspec.rb

@@ -1,4 +1,3 @@
-
 require 'mspec/runner/state'
 require 'mspec/runner/tag'
 require 'fileutils'
@@ -41,6 +40,9 @@ module MSpec
 
     shuffle files if randomize?
     files.each do |file|
+      @env = Object.new
+      @env.extend MSpec
+
       store :file, file
       actions :load
       protect("loading #{file}") { Kernel.load file }
@@ -65,8 +67,15 @@ module MSpec
     store :files, files
   end
 
-  def self.register_tags_path(path)
-    store :tags_path, path
+  # Stores one or more substitution patterns for transforming
+  # a spec filename into a tags filename, where each pattern
+  # has the form:
+  #
+  #   [Regexp, String]
+  #
+  # See also +tags_file+.
+  def self.register_tags_patterns(patterns)
+    store :tags_patterns, patterns
   end
 
   def self.register_mode(mode)
@@ -118,7 +127,7 @@ module MSpec
 
   def self.protect(msg, &block)
     begin
-      instance_eval(&block)
+      @env.instance_eval(&block)
     rescue Exception => e
       register_exit 1
       if current and current.state
@@ -168,18 +177,22 @@ module MSpec
     end
   end
 
-  def self.tags_path
-    retrieve(:tags_path) || "spec/tags"
-  end
-
+  # Transforms a spec filename into a tags filename by applying each
+  # substitution pattern in :tags_pattern. The default patterns are:
+  #
+  #   [%r(/spec/), '/spec/tags/'], [/_spec.rb$/, '_tags.txt']
+  #
+  # which will perform the following transformation:
+  #
+  #   path/to/spec/class/method_spec.rb => path/to/spec/tags/class/method_tags.txt
+  #
+  # See also +register_tags_patterns+.
   def self.tags_file
-    path = tags_path
-    file = retrieve :file
-    tags_file = File.basename(file, '.*').sub(/_spec$/, '_tags') + '.txt'
-
-    m = file.match %r[.*spec/(.*)/.*_spec.rb]
-    path = File.join(path, m[1]) if m
-    File.join path, tags_file
+    patterns = retrieve(:tags_patterns) ||
+               [[%r(spec/), 'spec/tags/'], [/_spec.rb$/, '_tags.txt']]
+    patterns.inject(retrieve(:file).dup) do |file, pattern|
+      file.gsub *pattern
+    end
   end
 
   def self.read_tags(*keys)