mspec 1.5.17 → 1.5.18

data/.gitignore

@@ -0,0 +1,27 @@
+pkg
+*.rbc
+*.iml
+*.iws
+*.ipr
+*.sw?
+
+.rbx
+
+# ctags dir
+/tags
+
+*.gem
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in mspec.gemspec
+gemspec

data/README

@@ -1,197 +1,77 @@
-= Overview
+1. Overview
 
 MSpec is a specialized framework that is syntax-compatible with RSpec for
-basic things like +describe+, +it+ blocks and +before+, +after+ actions. MSpec
+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.
 
 MSpec attempts to use the simplest Ruby language features so that beginning
-Ruby implementations can run the Ruby specs. So, for example, there is not
-great concern given to constant clashes. Namespacing (or module scoping) is
-not used because implementing this correctly took a significant amount of work
-in Rubinius and it is likely that other implementations would also face
-difficulties.
+Ruby implementations can run the Ruby specs.
 
 MSpec is not intended as a replacement for RSpec. MSpec attempts to provide a
 subset of RSpec's features in some cases and a superset in others. It does not
-provide all the matchers, for instance. However, MSpec provides several
-extensions to facilitate writing the Ruby specs in a manner compatible with
-multiple Ruby implementations.
-
-First, MSpec offers a set of guards to control execution of the specs. These
-guards not only enable or disable execution but also annotate the specs with
-additional information about why they are run or not run. Second, MSpec
-provides a different shared spec implementation specifically designed to ease
-writing specs for the numerous aliased methods in Ruby. The MSpec shared spec
-implementation should not conflict with RSpec's own shared behavior facility.
-Third, MSpec provides various helper methods to simplify some specs, for
-example, creating temporary file names. Finally, MSpec has several specialized
-runner scripts that includes a configuration facility with a default project
-file and user-specific overrides.
-
-Caveats:
-
-* Use RSpec to run the MSpec specs. There are no plans currently to make
-  the MSpec specs runnable by MSpec.
-* Don't mock the #hash method as MSpec's Mock implementation uses Hash
-  internally. This can be replaced if necessary, but at this point there is no
-  compelling need to do so.
-
-
-== Architecture
-
-
-== Matchers
-
-Matchers are additional aids for the verification process. The default
-is of course to #should or #should_not using the #== operator and its
-friends but the matchers add a new set of 'operators' to help in the
-task. They reside in `mspec/matchers/`. There are two broad categories,
-those that apply to an individual object and those that apply to a
-block:
-
-=== Object
-
-- `base` implements the standard #==, #< #<= #>= #> and #=~ with their
-  normal semantics for the objects that you invoke them on.
-
-- `be_ancestor_of` is equivalent to checking `obj.ancestors.include?`.
-
-- `be_close` is a "delta" for floating-point math. Due to the very
-  nature of it, floating-point comparisons should never be treated as
-  exact. By default the tolerance is 0.00003 but it can be altered if
-  so desired. So `0.23154.should be_close(0.23157)` would succeed
-  (which is usually close enough for floating point unless you are
-  doing some scientific computing.)
-
-- `be_empty` checks `obj.empty?`
-
-- `be_kind_of` is equivalent to `obj.kind_of?`
-
-- `include` is `obj.include?`
-
-=== Block
-
-All of these should be applied to a block created with `lambda` or `proc`:
-
-- `complain` is probably clearer stated as `lambda {...}.should complain`;
-  it checks that the block issues a warning. The message can be checked
-  against either a String or a Regexp.
-
-- `output` checks that the block produces the given output (stdout as well
-  as stderr, in that order) matched either to a String or a Regexp. This one
-  uses overrides so if that is a problem (for e.g. speccing Readline or
-  something) see below.
-
-- `output_to_fd` is a lower-level version and actually verifies that output
-  to a certain file descriptor is correct whether from an in-/output stream
-  or an actual file. Also can check with either a String or a Regexp.
+provide all the matchers, for instance.
 
-- `raise_error` verifies the exception type (if any) raised by the block it
-  is associated with. The exception class can be given for finer-grained
-  control (inheritance works normally so Exception would catch everything.)
+However, MSpec provides several extensions to facilitate writing the Ruby
+specs in a manner compatible with multiple Ruby implementations.
 
-== Nested 'describe' blocks
+  1. MSpec offers a set of guards to control execution of the specs. These
+     guards not only enable or disable execution but also annotate the specs
+     with additional information about why they are run or not run.
 
-MSpec supports nesting one 'describe' block inside another. The examples in
-the nested block are evaluated with all the before/after blocks of all the
-containing 'describe' blocks. The following example illustrates this:
+  2. MSpec provides a different shared spec implementation specifically
+     designed to ease writing specs for the numerous aliased methods in Ruby.
+     The MSpec shared spec implementation should not conflict with RSpec's own
+     shared behavior facility.
 
-describe "Some#method" do
-  before :each do
-    @obj = 1
-  end
+  3. MSpec provides various helper methods to simplify some specs, for
+     example, creating temporary file names.
 
-  describe "when passed String" do
-    before :each do
-      @meth = :to_s
-    end
+  4. MSpec has several specialized runner scripts that includes a
+     configuration facility with a default project file and user-specific
+     overrides.
 
-    it "returns false" do
-      # when this example is evaluated, @obj = 1 and @meth = :to_s
-    end
-  end
-end
 
-The output when using the SpecdocFormatter (selected with -fs to the runners)
-will be as follows:
+2. Bundler
 
-Some#method when passed String
-- returns false
+A Gemfile is provides. Use Bundler to install gem dependencies. To install
+Bundler, run the following:
 
+  $ gem install bundler
 
-== Shared 'describe' blocks
+To install the gem dependencies with Bundler, run the following:
 
-MSpec supports RSpec-style shared 'describe' blocks. MSpec also provides a
-convenience method to assist in writing specs for the numerous aliased methods
-that Ruby provides. The following example illustrates shared blocks:
+  $ RUBYLIB=lib ruby -S bundle install
 
-describe :someclass_some_method, :shared => true do
-  it "does something" do
-  end
-end
 
-describe "SomeClass#some_method" do
-  it_should_behave_like "someclass_some_method"
-end
+3. Running Specs
 
-The first argument to 'describe' for a shared block is an object that
-duck-types as a String. The representation of the object must be unique. This
-example uses a symbol. This was the convention for the previous facility that
-MSpec provided for aliased method (#it_behaves_like). However, this convention
-is not set in stone (but the uniqueness requirement is). Note that the
-argument to the #it_should_behave_like is a String because at this time RSpec
-will not find the shared block by the symbol.
+Use RSpec to run the MSpec specs. There are no plans currently to make the
+MSpec specs runnable by MSpec.
 
-MSpec continues to support the #it_behaves_like convenience method for
-specifying aliased methods. The syntax is as follows:
+After installing the gem dependencies, the specs can be run as follows:
 
-it_behaves_like :symbol_matching_shared_describe, :method [, :object]
+  $ ruby -S rspec
 
-describe :someclass_some_method, :shared => true do
-  it "returns true" do
-    obj.send(@method).should be_true
-  end
+Or
 
-  it "returns something else" do
-    @object.send(@method).should be_something_else
-  end
-end
+  $ ruby -S rake
 
-# example #1
-describe "SomeClass#some_method" do
-  it_behaves_like :someclass_some_method, :other_method
-end
+To run an individual spec file, use the following example:
 
-# example #2
-describe "SomeOtherClass#some_method" do
-  it_behaves_like :someclass_some_method, :some_method, OtherClass
-end
+  $ ruby -S rspec spec/helpers/ruby_exe_spec.rb
 
-The first form above (#1) is used for typical aliases. That is, methods with
-different names on the same class that behave identically. The
-#it_behaves_like helper creates a before(:all) block that sets @method to
-:other_method. The form of the first example block in the shared block
-illustrates the typical form of a spec for an aliased method.
 
-The second form above (#2) is used for methods on different classes that are
-essentially aliases, even though Ruby does not provide a syntax for specifying
-such methods as aliases. Examples are the methods on File, FileTest, and
-File::Stat. In this case, the #it_behaves_like helper sets both @method and
-@object in the before(:all) block (@method = :some_method, @object =
-OtherClass in this example).
+4. Documentation
 
-For shared specs that fall outside of either of these two narrow categories,
-use nested or shared 'describe' blocks as appropriate and use the
-#it_should_behave_like method directly.
+See http://rubyspec.org
 
-== Guards
 
-Since Ruby is not completely isolated from its platform or execution environment, the spec files may contain guards: conditions placed around a spec or a set of specs to enable or disable them. 
+5. Source Code
 
-You can find an overview of the current guards and their usage in: http://rubyspec.org/wiki/mspec/Guards .
+See https://github.com/rubyspec/mspec
 
-== Helpers
 
+6. License
 
-== Runners
+See the LICENSE in the source code.

data/Rakefile

@@ -1,47 +1,7 @@
-require 'rubygems'
-require 'spec/rake/spectask'
-require 'rake/gempackagetask'
+require 'bundler/gem_tasks'
+require 'bundler/setup'
+require 'rspec/core/rake_task'
 
-$:.unshift File.expand_path(File.dirname(__FILE__) + '/lib')
-require 'lib/mspec/version'
-
-Spec::Rake::SpecTask.new
+RSpec::Core::RakeTask.new(:spec)
 
 task :default => :spec
-
-
-spec = Gem::Specification.new do |s|
-  s.name                      = %q{mspec}
-  s.version                   = MSpec::VERSION.to_s
-
-  s.specification_version     = 2 if s.respond_to? :specification_version=
-
-  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
-  s.authors                   = ["Brian Ford"]
-  s.date                      = %q{2010-03-13}
-  s.email                     = %q{bford@engineyard.com}
-  s.has_rdoc                  = true
-  s.extra_rdoc_files          = %w[ README LICENSE ]
-  s.executables               = ["mkspec", "mspec", "mspec-ci", "mspec-run", "mspec-tag"]
-  s.files                     = FileList[ '{bin,lib,spec}/**/*.{yaml,txt,rb}', 'Rakefile', *s.extra_rdoc_files ]
-  s.homepage                  = %q{http://rubyspec.org}
-  s.rubyforge_project         = 'http://rubyforge.org/projects/mspec'
-  s.require_paths             = ["lib"]
-  s.rubygems_version          = %q{1.3.5}
-  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
-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 }

data/bin/mkspec.bat

@@ -0,0 +1 @@
+@"ruby.exe" "%~dpn0" %*

data/bin/mspec-ci.bat

@@ -0,0 +1 @@
+@"ruby.exe" "%~dpn0" %*

data/bin/mspec-run.bat

@@ -0,0 +1 @@
+@"ruby.exe" "%~dpn0" %*

data/bin/mspec-tag.bat

@@ -0,0 +1 @@
+@"ruby.exe" "%~dpn0" %*

data/bin/mspec.bat

@@ -0,0 +1 @@
+@"ruby.exe" "%~dpn0" %*

data/lib/mspec/commands/mkspec.rb

@@ -138,8 +138,8 @@ EOS
   # Determine and return the path of the ruby executable.
 
   def ruby
-    ruby = File.join(Config::CONFIG['bindir'],
-                     Config::CONFIG['ruby_install_name'])
+    ruby = File.join(RbConfig::CONFIG['bindir'],
+                     RbConfig::CONFIG['ruby_install_name'])
 
     ruby.gsub! File::SEPARATOR, File::ALT_SEPARATOR if File::ALT_SEPARATOR
 

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

@@ -34,6 +34,7 @@ class MSpecRun < MSpecScript
     options.configure { |f| load f }
     options.name
     options.randomize
+    options.repeat
     options.pretend
     options.background
     options.interrupt
@@ -68,6 +69,9 @@ class MSpecRun < MSpecScript
     options.doc "\n     $ mspec -g fails path/to/the_file_spec.rb"
     options.doc "\n   3. To start the debugger before the spec matching 'this crashes'"
     options.doc "\n     $ mspec --spec-debug -S 'this crashes' path/to/the_file_spec.rb"
+    options.doc "\n   4. To run some specs matching 'this crashes'"
+    options.doc "\n     $ mspec -e 'this crashes' path/to/the_file_spec.rb"
+    
     options.doc ""
 
     patterns = options.parse argv

data/lib/mspec/commands/mspec.rb

@@ -6,6 +6,7 @@ require 'mspec/version'
 require 'mspec/utils/options'
 require 'mspec/utils/script'
 require 'mspec/helpers/tmp'
+require 'mspec/runner/actions/filter'
 require 'mspec/runner/actions/timer'
 
 
@@ -17,6 +18,7 @@ class MSpecMain < MSpecScript
     config[:flags]    = []
     config[:command]  = nil
     config[:options]  = []
+    config[:launch]   = []
   end
 
   def options(argv=ARGV)
@@ -38,17 +40,21 @@ class MSpecMain < MSpecScript
     options.on("-D", "--gdb", "Run under gdb") do
       config[:use_gdb] = true
     end
+
     options.on("-A", "--valgrind", "Run under valgrind") do
-      config[:flags] << '--valgrind'
+      config[:use_valgrind] = true
     end
+
     options.on("--warnings", "Don't supress warnings") do
       config[:flags] << '-w'
       ENV['OUTPUT_WARNINGS'] = '1'
     end
+
     options.on("-j", "--multi", "Run multiple (possibly parallel) subprocesses") do
       config[:multi] = true
       config[:options] << "-fy"
     end
+
     options.version MSpec::VERSION do
       if config[:command]
         config[:options] << "-v"
@@ -57,6 +63,7 @@ class MSpecMain < MSpecScript
         exit
       end
     end
+
     options.help do
       if config[:command]
         config[:options] << "-h"
@@ -75,6 +82,7 @@ class MSpecMain < MSpecScript
     options.doc "   ci  - Run the known good specs"
     options.doc "   tag - Add or remove tags\n"
     options.doc " mspec COMMAND -h for more options\n"
+    options.doc "   example: $ mspec run -h\n"
 
     options.on_extra { |o| config[:options] << o }
     config[:options].concat options.parse(argv)
@@ -140,6 +148,8 @@ class MSpecMain < MSpecScript
     ENV['RUBY_FLAGS']   = config[:flags].join " "
 
     argv = []
+
+    argv.concat config[:launch]
     argv.concat config[:flags]
     argv.concat config[:includes]
     argv.concat config[:requires]
@@ -150,11 +160,16 @@ class MSpecMain < MSpecScript
     if config[:multi] and config[:command] == "ci"
       multi_exec argv
     else
-      if config[:use_gdb]
+      if config[:use_valgrind]
+        more = ["--db-attach=#{config[:use_gdb] ? 'yes' : 'no'}", config[:target]] + argv
+        exec "valgrind", *more
+      elsif config[:use_gdb]
         more = ["--args", config[:target]] + argv
         exec "gdb", *more
       else
-        exec config[:target], *argv
+        cmd, *rest = config[:target].split(/\s+/)
+        argv = rest + argv unless rest.empty?
+        exec cmd, *argv
       end
     end
   end