mspec 1.0.0

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

@@ -0,0 +1,80 @@
+#!/usr/bin/env ruby
+
+$:.unshift File.expand_path(File.dirname(__FILE__) + '/../lib')
+
+require 'optparse'
+require 'mspec/utils/options'
+require 'mspec/utils/script'
+
+
+class MSpecRun < MSpecScript
+  def options(argv=ARGV)
+    options = MSpecOptions.new config, "run", "", 28, "   "
+
+    options.separator " Ask yourself:"
+    options.separator "  1. What specs to run?"
+    options.separator "  2. How to modify the execution?"
+    options.separator "  3. How to display the output?"
+    options.separator "  4. What action to perform?"
+    options.separator "  5. When to perform it?"
+
+    options.separator "\n What specs to run"
+    options.add_filters
+
+    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
+
+    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.add_verify
+
+    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 some specs"
+    options.separator "\n     $ mspec path/to/the/specs"
+    options.separator "     mspec path/to/the_file_spec.rb"
+    options.separator "\n   2. To run specs tagged with 'fails'"
+    options.separator "\n     $ mspec -g fails path/to/the_file_spec.rb"
+    options.separator "\n   3. To start the debugger before the spec matching 'this crashes'"
+    options.separator "\n     $ mspec --spec-debug -S 'this crashes' path/to/the_file_spec.rb"
+    options.separator ""
+
+    @patterns = options.parse argv
+    if @patterns.empty?
+      puts options.parser
+      puts "No files specified."
+      exit 1
+    end
+  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
+
+    MSpec.process
+    exit MSpec.exit_code
+  end
+end
+

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

@@ -0,0 +1,87 @@
+#!/usr/bin/env ruby
+
+require 'optparse'
+require 'mspec/utils/options'
+require 'mspec/utils/script'
+
+
+class MSpecTag < MSpecScript
+  def initialize
+    super
+
+    config[:tagger]  = :add
+    config[:tag]     = 'fails:'
+    config[:outcome] = :fail
+  end
+
+  def options(argv=ARGV)
+    options = MSpecOptions.new config, "tag", "", 28, "   "
+
+    options.separator " Ask yourself:"
+    options.separator "  1. What specs to run?"
+    options.separator "  2. How to modify the execution?"
+    options.separator "  3. How to display the output?"
+    options.separator "  4. What tag action to perform?"
+    options.separator "  5. When to perform it?"
+
+    options.separator "\n What specs to run"
+    options.add_filters
+
+    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
+
+    options.separator "\n How to display their output"
+    options.add_formatters
+    options.add_verbose
+
+    options.separator "\n What action to perform and when to perform it"
+    options.add_tagging
+
+    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 add the 'fails' tag to failing specs"
+    options.separator "\n     $ mspec tag path/to/the_file_spec.rb"
+    options.separator "\n   2. To remove the 'fails' tag from passing specs"
+    options.separator "\n     $ mspec tag --del fails path/to/the_file_spec.rb"
+    options.separator ""
+
+    @patterns = options.parse argv
+    if @patterns.empty?
+      puts options.parser
+      puts "No files specified."
+      exit 1
+    end
+  end
+
+  def register
+    super
+
+    tag = SpecTag.new config[:tag]
+    tagger = TagAction.new(config[:tagger], config[:outcome], tag.tag, tag.comment,
+                           config[:atags], config[:astrings])
+    tagger.register
+  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
+
+    MSpec.process
+    exit MSpec.exit_code
+  end
+end
+

data/lib/mspec/commands/mspec.rb

@@ -0,0 +1,143 @@
+#!/usr/bin/env ruby
+
+MSPEC_HOME = File.expand_path(File.dirname(__FILE__) + '/../../..')
+
+require 'optparse'
+require 'mspec/utils/options'
+require 'mspec/utils/script'
+require 'mspec/helpers/tmp'
+require 'mspec/runner/actions/timer'
+
+
+class MSpecMain < MSpecScript
+  def initialize
+    config[:includes] = []
+    config[:requires] = []
+    config[:target]   = ENV['RUBY'] || 'ruby'
+    config[:flags]    = []
+    config[:command]  = nil
+    config[:options]  = []
+  end
+
+  def options(argv=ARGV)
+    if ["ci", "run", "tag"].include? argv[0]
+      config[:command] = argv.shift
+      config[:options] << "-h" if argv.delete("-h") || argv.delete("--help")
+      config[:options] << "-v" if argv.delete("-v") || argv.delete("--version")
+    end
+
+    options = MSpecOptions.new config, "[COMMAND]", "", 28, "   "
+
+    options.separator ""
+    options.separator "  The mspec command sets up and invokes the sub-commands"
+    options.separator "  (see below) to enable, for instance, running the specs"
+    options.separator "  with different implementations like ruby, jruby, rbx, etc.\n"
+
+    options.add_config do |f|
+      config[:options] << '-B' << f
+    end
+
+    options.add_targets
+
+    options.on("-D", "--gdb", "Run under gdb") do
+      config[:flags] << '--gdb'
+    end
+    options.on("-A", "--valgrind", "Run under valgrind") do
+      config[:flags] << '--valgrind'
+    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.add_version
+    options.on("-h", "--help", "Show this message") do
+      puts options.parser
+      exit
+    end
+
+    # The rest of the help output
+    options.separator "\n  where COMMAND is one of:\n"
+    options.separator "    run - Run the specified specs (default)"
+    options.separator "    ci  - Run the known good specs"
+    options.separator "    tag - Add or remove tags\n"
+    options.separator "  mspec COMMAND -h for more options\n"
+
+    config[:options] += options.parser.filter! argv
+    options.parse argv
+  end
+
+  def register; end
+
+  def parallel
+    @parallel ||= !(Object.const_defined?(:JRUBY_VERSION) ||
+                  /(mswin|mingw)/ =~ RUBY_PLATFORM)
+  end
+
+  def fork(&block)
+    parallel ? Kernel.fork(&block) : block.call
+  end
+
+  def report(files, timer)
+    require 'yaml'
+
+    exceptions = []
+    tally = Tally.new
+
+    files.each do |file|
+      d = File.open(file, "r") { |f| YAML.load f }
+      File.delete file
+
+      exceptions += Array(d['exceptions'])
+      tally.files!        d['files']
+      tally.examples!     d['examples']
+      tally.expectations! d['expectations']
+      tally.errors!       d['errors']
+      tally.failures!     d['failures']
+    end
+
+    print "\n"
+    exceptions.each_with_index do |exc, index|
+      print "\n#{index+1})\n", exc, "\n"
+    end
+    print "\n#{timer.format}\n\n#{tally.format}\n"
+  end
+
+  def multi_exec(argv)
+    timer = TimerAction.new
+    timer.start
+
+    files = config[:ci_files].inject([]) do |list, item|
+      name = tmp "mspec-ci-multi-#{list.size}"
+
+      rest = argv + ["-o", name, item]
+      fork { system [config[:target], *rest].join(" ") }
+
+      list << name
+    end
+
+    Process.waitall
+    timer.finish
+    report files, timer
+  end
+
+  def run
+    ENV['MSPEC_RUNNER'] = '1'
+
+    argv = config[:flags]
+    argv.concat config[:includes]
+    argv.concat config[:requires]
+    argv << "#{MSPEC_HOME}/bin/mspec-#{ config[:command] || "run" }"
+    argv.concat config[:options]
+
+    if config[:multi] and config[:command] == "ci"
+      multi_exec argv
+    else
+      exec config[:target], *argv
+    end
+  end
+end
+

data/lib/mspec/expectations.rb

@@ -0,0 +1,2 @@
+require 'mspec/expectations/expectations'
+require 'mspec/expectations/should'

data/lib/mspec/expectations/expectations.rb

@@ -0,0 +1,12 @@
+class ExpectationNotMetError < StandardError; end
+
+class Expectation
+  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
+  end
+end

data/lib/mspec/expectations/should.rb

@@ -0,0 +1,23 @@
+class Object
+  def should(matcher=nil)
+    MSpec.actions :expectation, MSpec.current.state
+    if matcher
+      unless matcher.matches?(self)
+        Expectation.fail_with(*matcher.failure_message)
+      end
+    else
+      PositiveOperatorMatcher.new(self)
+    end
+  end
+
+  def should_not(matcher=nil)
+    MSpec.actions :expectation, MSpec.current.state
+    if matcher
+      if matcher.matches?(self)
+        Expectation.fail_with(*matcher.negative_failure_message)
+      end
+    else
+      NegativeOperatorMatcher.new(self)
+    end
+  end
+end

data/lib/mspec/guards.rb

@@ -0,0 +1,13 @@
+require 'mspec/guards/bug'
+require 'mspec/guards/compliance'
+require 'mspec/guards/extensions'
+require 'mspec/guards/guard'
+require 'mspec/guards/noncompliance'
+require 'mspec/guards/platform'
+require 'mspec/guards/quarantine'
+require 'mspec/guards/runner'
+require 'mspec/guards/support'
+require 'mspec/guards/endian'
+require 'mspec/guards/superuser'
+require 'mspec/guards/conflict'
+require 'mspec/guards/version'

data/lib/mspec/guards/bug.rb

@@ -0,0 +1,27 @@
+require 'mspec/guards/version'
+
+class BugGuard < VersionGuard
+  def initialize(bug, version)
+    @bug = bug
+    @version = to_v version
+  end
+
+  def to_v(str)
+    major, minor, tiny, patch = str.split "."
+    tiny = 99 unless tiny
+    patch = 9999 unless patch
+    ("1%02d%02d%02d%04d" % [major, minor, tiny, patch].map { |x| x.to_i }).to_i
+  end
+
+  def match?
+    implementation?(:ruby, :ruby18, :ruby19) && ruby_version <= @version
+  end
+end
+
+class Object
+  def ruby_bug(bug="Please add a bug tracker number", version="0")
+    g = BugGuard.new bug, version
+    yield if g.yield? true
+    g.unregister
+  end
+end

data/lib/mspec/guards/compliance.rb

@@ -0,0 +1,18 @@
+require 'mspec/guards/guard'
+
+class ComplianceGuard < SpecGuard
+end
+
+class Object
+  def compliant_on(*args)
+    g = ComplianceGuard.new(*args)
+    yield if g.yield?
+    g.unregister
+  end
+
+  def not_compliant_on(*args)
+    g = ComplianceGuard.new(*args)
+    yield if g.yield? true
+    g.unregister
+  end
+end

data/lib/mspec/guards/conflict.rb

@@ -0,0 +1,16 @@
+require 'mspec/guards/guard'
+
+class ConflictsGuard < SpecGuard
+  def match?
+    constants = Object.constants
+    @args.any? { |mod| constants.include? mod.to_s }
+  end
+end
+
+class Object
+  def conflicts_with(*modules)
+    g = ConflictsGuard.new(*modules)
+    yield if g.yield? true
+    g.unregister
+  end
+end

data/lib/mspec/guards/endian.rb

@@ -0,0 +1,40 @@
+require 'mspec/guards/guard'
+
+# Despite that these are inverses, the two classes are
+# used to simplify MSpec guard reporting modes
+
+class BigEndianGuard < SpecGuard
+  def pattern
+    [1].pack('L')
+  end
+  private :pattern
+
+  def match?
+    pattern[-1] == 1
+  end
+end
+
+class LittleEndianGuard < SpecGuard
+  def pattern
+    [1].pack('L')
+  end
+  private :pattern
+
+  def match?
+    pattern[-1] == 0
+  end
+end
+
+class Object
+  def big_endian
+    g = BigEndianGuard.new
+    yield if g.yield?
+    g.unregister
+  end
+
+  def little_endian
+    g = LittleEndianGuard.new
+    yield if g.yield?
+    g.unregister
+  end
+end