mspec 1.0.0

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2008 Engine Yard, Inc. All rights reserved.
+
+Permission is hereby granted, free of charge, to any person
+obtaining a copy of this software and associated documentation
+files (the "Software"), to deal in the Software without
+restriction, including without limitation the rights to use,
+copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the
+Software is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+OTHER DEALINGS IN THE SOFTWARE.

data/README

@@ -0,0 +1,101 @@
+= Overview
+
+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.
+
+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.
+
+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.
+
+- `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.)
+
+
+== Guards
+
+
+== Helpers
+
+
+== Runners

data/Rakefile

@@ -0,0 +1,44 @@
+require 'rubygems'
+require 'spec/rake/spectask'
+require 'rake/gempackagetask'
+
+Spec::Rake::SpecTask.new
+
+task :default => :spec
+
+
+spec = Gem::Specification.new do |s|
+  s.name                      = %q{mspec}
+  s.version                   = "1.0.0"
+
+  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{2008-05-21}
+  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.1.1}
+  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

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+
+$:.unshift File.expand_path(File.dirname(__FILE__) + '/../lib')
+
+require 'mspec/commands/mkspec'
+
+MkSpec.main

data/bin/mspec

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+
+$:.unshift File.expand_path(File.dirname(__FILE__) + '/../lib')
+
+require 'mspec/commands/mspec'
+
+MSpecMain.main

data/bin/mspec-ci

@@ -0,0 +1,8 @@
+#!/usr/bin/env ruby
+
+$:.unshift File.expand_path(File.dirname(__FILE__) + '/../lib')
+
+require 'mspec/commands/mspec-ci'
+require 'mspec'
+
+MSpecCI.main

data/bin/mspec-run

@@ -0,0 +1,8 @@
+#!/usr/bin/env ruby
+
+$:.unshift File.expand_path(File.dirname(__FILE__) + '/../lib')
+
+require 'mspec/commands/mspec-run'
+require 'mspec'
+
+MSpecRun.main

data/bin/mspec-tag

@@ -0,0 +1,8 @@
+#!/usr/bin/env ruby
+
+$:.unshift File.expand_path(File.dirname(__FILE__) + '/../lib')
+
+require 'mspec/commands/mspec-tag'
+require 'mspec'
+
+MSpecTag.main

data/lib/mspec.rb

@@ -0,0 +1,6 @@
+require 'mspec/matchers'
+require 'mspec/expectations'
+require 'mspec/mocks'
+require 'mspec/runner'
+require 'mspec/guards'
+require 'mspec/helpers'

data/lib/mspec/commands/mkspec.rb

@@ -0,0 +1,147 @@
+#! /usr/bin/env ruby
+
+MSPEC_HOME = File.expand_path(File.dirname(__FILE__) + '/../../..')
+
+require 'fileutils'
+require 'optparse'
+require 'rbconfig'
+require 'mspec/version'
+require 'mspec/utils/name_map'
+
+
+class MkSpec
+  attr_reader :config
+
+  def initialize
+    @config = {
+      :constants => [],
+      :requires  => [],
+      :base      => "spec/ruby/1.8/core"
+    }
+    @map = NameMap.new
+  end
+
+  def options(argv=ARGV)
+    options = OptionParser.new
+    options.version = MSpec::VERSION
+    options.banner = "mkspec [options]"
+    options.separator ""
+
+    options.on("-c", "--constant CONSTANT", String,
+               "Class or Module to generate spec stubs for") do |name|
+      config[:constants] << name
+    end
+    options.on("-b", "--base DIR", String,
+               "Directory to generate specs into") do |directory|
+      config[:base] = File.expand_path directory
+    end
+    options.on("-r", "--require LIBRARY", String,
+               "A library to require") do |file|
+      config[:requires] << file
+    end
+
+    options.separator "\n How might this work in the real world?\n"
+    options.separator "   1. To create spec stubs for every class or module in Object\n"
+    options.separator "     $ mkspec\n"
+    options.separator "   2. To create spec stubs for Fixnum\n"
+    options.separator "     $ mkspec -c Fixnum\n"
+    options.separator "   3. To create spec stubs for Complex in 'superspec/complex'\n"
+    options.separator "     $ mkspec -c Complex -rcomplex -b superspec"
+    options.separator ""
+
+    options.parse argv
+  rescue OptionParser::ParseError => e
+    puts options
+    puts
+    puts e
+    exit 1
+  end
+
+  def create_directory(mod)
+    subdir = @map.dir_name mod, config[:base]
+
+    if File.exist? subdir
+      unless File.directory? subdir
+        puts "#{subdir} already exists and is not a directory."
+        return nil
+      end
+    else
+      FileUtils.mkdir_p subdir
+    end
+
+    subdir
+  end
+
+  def write_requires(dir, file)
+    /\A#{Regexp.escape config[:base]}\/?(.*)/ =~ dir
+    parents = '../' * ($1.split('/').length + 1)
+
+    File.open file, 'w' do |f|
+      f.puts "require File.dirname(__FILE__) + '/#{parents}spec_helper'"
+      config[:requires].each do |lib|
+        f.puts "require '#{lib}'"
+      end
+    end
+  end
+
+  def write_spec(file, meth, exists)
+    if exists
+      out = `#{ruby} #{MSPEC_HOME}/bin/mspec-run --dry-run -fs -e '#{meth}' #{file}`
+      return if out =~ /#{Regexp.escape meth}/
+    end
+
+    File.open file, 'a' do |f|
+      f.puts <<-EOS
+
+describe "#{meth}" do
+  it "needs to be reviewed for spec completeness" do
+  end
+end
+EOS
+    end
+
+    puts file
+  end
+
+  def create_file(dir, mod, meth, name)
+    file = File.join dir, @map.file_name(meth, mod)
+    exists = File.exist? file
+
+    write_requires dir, file unless exists
+    write_spec file, name, exists
+  end
+
+  def run
+    config[:requires].each { |lib| require lib }
+    constants = config[:constants]
+    constants = @map.filter(Object.constants) if constants.empty?
+
+    @map.map({}, constants).each do |mod, methods|
+      name = mod.chop
+      next unless dir = create_directory(name)
+
+      methods.each { |method| create_file dir, name, method, mod + method }
+    end
+  end
+  
+  ##
+  # Determine and return the path of the ruby executable.
+
+  def ruby
+    ruby = File.join(Config::CONFIG['bindir'],
+                     Config::CONFIG['ruby_install_name'])
+
+    ruby.gsub! File::SEPARATOR, File::ALT_SEPARATOR if File::ALT_SEPARATOR
+
+    return ruby
+  end
+
+  def self.main
+    ENV['MSPEC_RUNNER'] = '1'
+
+    script = new
+    script.options
+    script.run
+  end
+end
+

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

@@ -0,0 +1,71 @@
+#!/usr/bin/env ruby
+
+$:.unshift File.expand_path(File.dirname(__FILE__) + '/../lib')
+
+require 'optparse'
+require 'mspec/utils/options'
+require 'mspec/utils/script'
+
+
+class MSpecCI < MSpecScript
+  def options(argv=ARGV)
+    options = MSpecOptions.new config, "ci", "", 28, "   "
+
+    options.separator " Ask yourself:"
+    options.separator "  1. How to run the specs?"
+    options.separator "  2. How to display the output?"
+    options.separator "  3. What action to perform?"
+    options.separator "  4. When to perform it?"
+
+    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
+
+    options.separator "\n How to display their output"
+    options.add_formatters
+    options.add_verbose
+
+    options.separator "\n What action to perform"
+    options.add_actions
+
+    options.separator "\n When to perform it"
+    options.add_action_filters
+
+    options.separator "\n Help!"
+    options.add_version
+    options.add_help
+
+    options.separator "\n How might this work in the real world?"
+    options.separator "\n   1. To simply run the known good specs"
+    options.separator "\n     $ mspec ci"
+    options.separator "\n   2. To run a subset of the known good specs"
+    options.separator "\n     $ mspec ci path/to/specs"
+    options.separator "\n   3. To start the debugger before the spec matching 'this crashes'"
+    options.separator "\n     $ mspec ci --spec-debug -S 'this crashes'"
+    options.separator ""
+
+    @patterns = options.parse argv
+    @patterns = config[:ci_files] if @patterns.empty?
+  end
+
+  def run
+    files = []
+    @patterns.each do |item|
+      stat = File.stat(File.expand_path(item))
+      files << item if stat.file?
+      files.concat(Dir[item+"/**/*_spec.rb"].sort) if stat.directory?
+    end
+
+    MSpec.register_tags_path config[:tags_dir]
+    MSpec.register_files files
+    TagFilter.new(:exclude, "fails").register
+    TagFilter.new(:exclude, "unstable").register
+    TagFilter.new(:exclude, "incomplete").register
+
+    MSpec.process
+    exit MSpec.exit_code
+  end
+end