opal-wedge 0.9.0.dev

data/stdlib/time.rb

@@ -0,0 +1,9 @@
+class Time
+  def self.parse(str)
+    `new Date(Date.parse(str))`
+  end
+
+  def iso8601
+    strftime('%FT%T%z')
+  end
+end

data/stdlib/yaml.rb

@@ -0,0 +1 @@
+require 'nodejs/yaml' if defined? NodeJS

data/tasks/benchmarking.rake

@@ -0,0 +1,88 @@
+namespace :bench do
+  directory "tmp/bench"
+
+  desc "Benchmark Opal"
+  task :opal => "tmp/bench" do |t, args|
+    files = Array(args[:files]) + args.extras
+    index = 0
+    begin
+      index += 1
+      report = "tmp/bench/Opal#{index}"
+    end while File.exist?(report)
+    sh "bundle exec opal benchmark/run.rb #{files.join(" ")} | tee #{report}"
+  end
+
+  desc "Benchmark Ruby"
+  task :ruby => "tmp/bench" do |t, args|
+    files = Array(args[:files]) + args.extras
+    index = 0
+    begin
+      index += 1
+      report = "tmp/bench/Ruby#{index}"
+    end while File.exist?(report)
+    sh "bundle exec ruby benchmark/run.rb #{files.join(" ")} | tee #{report}"
+  end
+
+  desc "Delete all benchmark results"
+  task :clear do
+    sh "rm tmp/bench/*"
+  end
+
+  desc "Combined report of all benchmark results"
+  task :report do |t, args|
+    files = Array(args[:files]) + args.extras
+    if files.empty?
+      files = Dir["tmp/bench/*"]
+    else
+      files = files.map{|file| "tmp/bench/#{ file }"}
+    end
+    reports = []
+    benchmark_names = []
+
+    files.each do |file|
+      report_name = File.basename(file, File.extname(file))
+      report_results = {}
+      File.read(file).each_line do |line|
+        benchmark_name, benchmark_result = line.split(" ")
+        report_results[benchmark_name] = benchmark_result
+        benchmark_names << benchmark_name
+      end
+      reports << [report_name, report_results]
+    end
+
+    benchmark_names.uniq!
+
+    header = ["Benchmark"]
+    reports.each do |report_name, _|
+      header << report_name
+    end
+
+    table = [header]
+    benchmark_names.each do |benchmark_name|
+      row = [benchmark_name]
+      reports.each do |_, report_results|
+        if report_results[benchmark_name]
+          row << format("%0.3f", report_results[benchmark_name])
+        else
+          row << ""
+        end
+      end
+      table << row
+    end
+
+    fmt = ""
+    table.transpose.each_with_index do |column, index|
+      column_width = column.max_by{|string| string.length}.length
+      if index.zero?
+        fmt << "%-#{ column_width }s"
+      else
+        fmt << "  %#{ column_width }s"
+      end
+    end
+    fmt << "\n"
+
+    table.each do |row|
+      printf fmt, *row
+    end
+  end
+end

data/tasks/building.rake

@@ -0,0 +1,58 @@
+require 'opal/version'
+
+desc <<-DESC
+Build *corelib* and *stdlib* to "build/"
+
+You can restrict the file list with the FILES env var (comma separated)
+and the destination dir with the DIR env var.
+
+Example: rake dist DIR=/tmp/foo FILES='opal.rb,base64.rb'
+Example: rake dist DIR=cdn/opal/#{Opal::VERSION}
+Example: rake dist DIR=cdn/opal/master
+DESC
+task :dist do
+  require 'opal/util'
+  require 'opal/sprockets/environment'
+
+  Opal::Processor.arity_check_enabled = false
+  Opal::Processor.const_missing_enabled = false
+  Opal::Processor.dynamic_require_severity = :warning
+  env = Opal::Environment.new
+
+  build_dir = ENV['DIR'] || 'build'
+  files     = ENV['FILES'] ? ENV['FILES'].split(',') :
+              Dir['{opal,stdlib}/*.rb'].map { |lib| File.basename(lib, '.rb') }
+
+  Dir.mkdir build_dir unless File.directory? build_dir
+  width = files.map(&:size).max
+
+  files.each do |lib|
+    print "* building #{lib}...".ljust(width+'* building ... '.size)
+    $stdout.flush
+
+    src = env[lib].to_s
+    min = Opal::Util.uglify src
+    gzp = Opal::Util.gzip min
+
+    File.open("#{build_dir}/#{lib}.js", 'w+')        { |f| f << src }
+    File.open("#{build_dir}/#{lib}.min.js", 'w+')    { |f| f << min } if min
+    File.open("#{build_dir}/#{lib}.min.js.gz", 'w+') { |f| f << gzp } if gzp
+
+    print "done. ("
+    print "development: #{('%.2f' % (src.size/1000.0)).rjust(6)}KB"
+    print  ", minified: #{('%.2f' % (min.size/1000.0)).rjust(6)}KB" if min
+    print   ", gzipped: #{('%.2f' % (gzp.size/1000.0)).rjust(6)}KB" if gzp
+    puts  ")."
+  end
+end
+
+desc 'Rebuild grammar.rb for opal parser'
+task :racc do
+  %x(racc -l lib/opal/parser/grammar.y -o lib/opal/parser/grammar.rb)
+end
+
+desc 'Remove any generated file.'
+task :clobber do
+  rm_r './build'
+end
+

data/tasks/documenting.rake

@@ -0,0 +1,37 @@
+namespace :doc do
+  doc_repo = Pathname(ENV['DOC_REPO'] || 'gh-pages')
+  doc_base = doc_repo.join('doc')
+  current_git_release = -> { `git rev-parse --abbrev-ref HEAD`.chomp }
+  template_option = "--template opal --template-path #{doc_repo.join('yard-templates')}"
+
+  directory doc_repo.to_s do
+    remote = ENV['DOC_REPO_REMOTE'] || '.'
+    sh 'git', 'clone', '-b', 'gh-pages', '--', remote, doc_repo.to_s
+  end
+
+  task :corelib => doc_repo.to_s do
+    git  = current_git_release.call
+    name = 'corelib'
+    glob = 'opal/**/*.rb'
+
+    command = "doxx --template #{doc_repo.join('doxx-templates/opal.jade')} "\
+              "--source opal/corelib --target #{doc_base}/#{git}/#{name} "\
+              "--title \"Opal runtime.js Documentation\" --readme opal/README.md"
+    puts command; system command or $stderr.puts "Please install doxx with: npm install"
+
+    command = "yard doc #{glob} #{template_option} "\
+              "--readme opal/README.md -o #{doc_base}/#{git}/#{name}"
+    puts command; system command
+  end
+
+  task :stdlib => doc_repo do
+    git  = current_git_release.call
+    name = 'stdlib'
+    glob = '{stdlib/**/*,opal/compiler,opal/erb,opal/version}.rb'
+    command = "yard doc #{glob} #{template_option} "\
+              "--readme stdlib/README.md -o gh-pages/doc/#{git}/#{name}"
+    puts command; system command
+  end
+end
+
+task :doc => ['doc:corelib', 'doc:stdlib']

data/tasks/github.rake

@@ -0,0 +1,19 @@
+namespace :github do
+  desc "Upload assets to github"
+  task :upload_assets do
+    require 'octokit'
+    # https://github.com/octokit/octokit.rb#oauth-access-tokens
+    token_path = '.github_access_token'
+    File.exist?(token_path) or raise ArgumentError, "Please create a personal access token (https://github.com/settings/tokens/new) and paste it inside #{token_path.inspect}"
+    token = File.read(token_path).strip
+    client = Octokit::Client.new :access_token => token
+    tag_name = ENV['TAG'] || raise(ArgumentError, 'missing the TAG env variable (e.g. TAG=v0.4.4)')
+    release = client.releases('opal/opal').find{|r| p(r.id); p(r).tag_name == tag_name}
+    release_url = "https://api.github.com/repos/opal/opal/releases/#{release.id}"
+    %w[opal opal-parser].each do |name|
+      client.upload_asset release_url, "build/#{name}.js", :content_type => 'application/x-javascript'
+      client.upload_asset release_url, "build/#{name}.min.js", :content_type => 'application/x-javascript'
+      client.upload_asset release_url, "build/#{name}.min.js.gz", :content_type => 'application/octet-stream'
+    end
+  end
+end

data/tasks/linting.rake

@@ -0,0 +1,18 @@
+directory 'tmp/lint'
+
+desc "Build *corelib* and *stdlib* and lint the result"
+task :lint => 'tmp/lint' do
+  require 'opal/sprockets/environment'
+
+  env = Opal::Environment.new
+
+  files = Dir['{opal,stdlib}/*.rb'].map { |lib| File.basename(lib, '.rb') }
+
+  files.each do |lib|
+    next if lib == 'minitest'
+    File.binwrite("tmp/lint/#{lib}.js", env[lib].to_s)
+  end
+
+  sh "jshint --verbose tmp/lint/*.js"
+end
+

data/tasks/testing.rake

@@ -0,0 +1,125 @@
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:rspec) do |t|
+  t.pattern = 'spec/lib/**/*_spec.rb'
+end
+
+require 'mspec/opal/rake_task'
+MSpec::Opal::RakeTask.new(:mspec_phantom) do |config|
+  config.pattern = ENV['MSPEC_PATTERN'] if ENV['MSPEC_PATTERN']
+  config.basedir = ENV['MSPEC_BASEDIR'] if ENV['MSPEC_BASEDIR']
+end
+
+desc <<-DESC
+Run the MSpec test suite on node
+
+Use PATTERN and env var to manually set the glob for specs:
+
+  # Will run all specs matching the specified pattern.
+  # (Note: the rubyspecs filters will still apply)
+  rake mspec_node PATTERN=spec/rubyspec/core/module/class_variable*
+DESC
+task :mspec_node do
+  excepting = []
+  rubyspecs = File.read('spec/rubyspecs').lines.reject do |l|
+    l.strip!; l.start_with?('#') || l.empty? || (l.start_with?('!') && excepting.push(l.sub('!', 'spec/') + '.rb'))
+  end.flat_map do |path|
+    path = "spec/#{path}"
+    File.directory?(path) ? Dir[path+'/*.rb'] : "#{path}.rb"
+  end - excepting
+
+  filters = Dir['spec/filters/**/*.rb']
+  shared = Dir['spec/{opal,lib/parser}/**/*_spec.rb'] + ['spec/lib/lexer_spec.rb']
+
+  specs = []
+  add_specs = ->(name, new_specs) { p [new_specs.size, name]; specs + new_specs}
+
+  specs = add_specs.(:filters, filters)
+  pattern = ENV['PATTERN']
+  whitelist_pattern = !!ENV['RUBYSPECS']
+
+  if pattern
+    custom = Dir[pattern]
+    custom &= rubyspecs if whitelist_pattern
+    specs = add_specs.(:custom, custom)
+  else
+    specs = add_specs.(:shared, shared)
+    specs = add_specs.(:rubyspecs, rubyspecs)
+  end
+
+  requires = specs.map{|s| "require '#{s.sub(/^spec\//,'')}'"}
+  include_paths = '-Ispec -Ilib'
+
+  filename = 'tmp/mspec_node.rb'
+  js_filename = 'tmp/mspec_node.js'
+  mkdir_p File.dirname(filename)
+
+  if ENV['BM']
+    mkdir_p 'tmp/bench'
+    index = 0
+    begin
+      index += 1
+      bm_filepath = "tmp/bench/Spec#{index}"
+    end while File.exist?(bm_filepath)
+    enter_benchmarking_mode = "OSpecRunner.main.bm!(#{Integer(ENV['BM'])}, '#{bm_filepath}')"
+  end
+
+  File.write filename, <<-RUBY
+    require 'spec_helper'
+    #{enter_benchmarking_mode}
+    #{requires.join("\n    ")}
+    OSpecRunner.main.did_finish
+  RUBY
+
+  stubs = '-smspec/helpers/tmp -smspec/helpers/environment -smspec/guards/block_device -smspec/guards/endian'
+
+  sh "ruby -rbundler/setup -rmspec/opal/special_calls "\
+     "bin/opal -gmspec #{include_paths} #{stubs} -rnodejs/io -rnodejs/kernel -Dwarning -A #{filename} -c > #{js_filename}"
+  sh "jshint --verbose #{js_filename}"
+  sh "NODE_PATH=stdlib/nodejs/node_modules node #{js_filename}"
+
+  if bm_filepath
+    puts "Benchmark results have been written to #{bm_filepath}"
+    puts "To view the results, run bundle exec rake bench:report"
+  end
+end
+
+task :cruby_tests do
+  if ENV.key? 'FILES'
+    files = Dir[ENV['FILES'] || 'test/test_*.rb']
+    include_paths = '-Itest -I. -Itmp -Ilib'
+  else
+    include_paths = '-Itest/cruby/test'
+    test_dir = Pathname("#{__dir__}/../test/cruby/test")
+    files = %w[
+      benchmark/test_benchmark.rb
+      ruby/test_call.rb
+    ].flat_map do |path|
+      if path.end_with?('.rb')
+        path
+      else
+        glob = test_dir.join(path+"/test_*.rb").to_s
+        size = test_dir.to_s.size
+        Dir[glob].map { |file| file[size+1..-1] }
+      end
+    end
+  end
+  include_paths << ' -Ivendored-minitest'
+
+  requires = files.map{|f| "require '#{f}'"}
+  filename = 'tmp/cruby_tests.rb'
+  js_filename = 'tmp/cruby_tests.js'
+  mkdir_p File.dirname(filename)
+  File.write filename, requires.join("\n")
+
+  stubs = "-soptparse -sio/console -stimeout -smutex_m -srubygems -stempfile -smonitor"
+
+  puts "== Running: #{files.join ", "}"
+
+  sh "ruby -rbundler/setup "\
+     "bin/opal #{include_paths} #{stubs} -rnodejs -Dwarning -A #{filename} -c > #{js_filename}"
+  sh "NODE_PATH=stdlib/nodejs/node_modules node #{js_filename}"
+end
+
+task :mspec    => [:mspec_node, :mspec_phantom]
+task :minitest => [:cruby_tests]
+task :test_all => [:rspec, :mspec, :minitest]

data/vendored-minitest/minitest.rb

@@ -0,0 +1,780 @@
+require "optparse"
+require "thread"
+require "mutex_m"
+require "minitest/parallel"
+
+##
+# :include: README.txt
+
+module Minitest
+  VERSION = "5.5.1" # :nodoc:
+  ENCS = "".respond_to? :encoding # :nodoc:
+
+  @@installed_at_exit ||= false
+  @@after_run = []
+  @extensions = []
+
+  mc = (class << self; self; end)
+
+  ##
+  # Parallel test executor
+
+  mc.send :attr_accessor, :parallel_executor
+  self.parallel_executor = Parallel::Executor.new((ENV['N'] || 2).to_i)
+
+  ##
+  # Filter object for backtraces.
+
+  mc.send :attr_accessor, :backtrace_filter
+
+  ##
+  # Reporter object to be used for all runs.
+  #
+  # NOTE: This accessor is only available during setup, not during runs.
+
+  mc.send :attr_accessor, :reporter
+
+  ##
+  # Names of known extension plugins.
+
+  mc.send :attr_accessor, :extensions
+
+  ##
+  # Registers Minitest to run at process exit
+
+  def self.autorun
+    at_exit {
+      next if $! and not ($!.kind_of? SystemExit and $!.success?)
+
+      exit_code = nil
+
+      at_exit {
+        @@after_run.reverse_each(&:call)
+        exit exit_code || false
+      }
+
+      exit_code = Minitest.run ARGV
+    } unless @@installed_at_exit
+    @@installed_at_exit = true
+  end
+
+  ##
+  # A simple hook allowing you to run a block of code after everything
+  # is done running. Eg:
+  #
+  #   Minitest.after_run { p $debugging_info }
+
+  def self.after_run &block
+    @@after_run << block
+  end
+
+  def self.init_plugins options # :nodoc:
+    self.extensions.each do |name|
+      msg = "plugin_#{name}_init"
+      send msg, options if self.respond_to? msg
+    end
+  end
+
+  def self.load_plugins # :nodoc:
+    # return unless self.extensions.empty?
+    #
+    # seen = {}
+    #
+    # require "rubygems" unless defined? Gem
+    #
+    # Gem.find_files("minitest/*_plugin.rb").each do |plugin_path|
+    #   name = File.basename plugin_path, "_plugin.rb"
+    #
+    #   next if seen[name]
+    #   seen[name] = true
+    #
+    #   require plugin_path
+    #   self.extensions << name
+    # end
+  end
+
+  ##
+  # This is the top-level run method. Everything starts from here. It
+  # tells each Runnable sub-class to run, and each of those are
+  # responsible for doing whatever they do.
+  #
+  # The overall structure of a run looks like this:
+  #
+  #   Minitest.autorun
+  #     Minitest.run(args)
+  #       Minitest.__run(reporter, options)
+  #         Runnable.runnables.each
+  #           runnable.run(reporter, options)
+  #             self.runnable_methods.each
+  #               self.run_one_method(self, runnable_method, reporter)
+  #                 Minitest.run_one_method(klass, runnable_method, reporter)
+  #                   klass.new(runnable_method).run
+
+  def self.run args = []
+    self.load_plugins
+
+    options = process_args args
+
+    reporter = CompositeReporter.new
+    reporter << SummaryReporter.new(options[:io], options)
+    reporter << ProgressReporter.new(options[:io], options)
+
+    self.reporter = reporter # this makes it available to plugins
+    self.init_plugins options
+    self.reporter = nil # runnables shouldn't depend on the reporter, ever
+
+    reporter.start
+    __run reporter, options
+    self.parallel_executor.shutdown
+    reporter.report
+
+    reporter.passed?
+  end
+
+  ##
+  # Internal run method. Responsible for telling all Runnable
+  # sub-classes to run.
+  #
+  # NOTE: this method is redefined in parallel_each.rb, which is
+  # loaded if a Runnable calls parallelize_me!.
+
+  def self.__run reporter, options
+    suites = Runnable.runnables.shuffle
+    parallel, serial = suites.partition { |s| s.test_order == :parallel }
+
+    # If we run the parallel tests before the serial tests, the parallel tests
+    # could run in parallel with the serial tests. This would be bad because
+    # the serial tests won't lock around Reporter#record. Run the serial tests
+    # first, so that after they complete, the parallel tests will lock when
+    # recording results.
+    serial.map { |suite| suite.run reporter, options } +
+      parallel.map { |suite| suite.run reporter, options }
+  end
+
+  def self.process_args args = [] # :nodoc:
+    options = {
+               :io => $stdout,
+              }
+    orig_args = args.dup
+
+    OptionParser.new do |opts|
+      opts.banner  = "minitest options:"
+      opts.version = Minitest::VERSION
+
+      opts.on "-h", "--help", "Display this help." do
+        puts opts
+        exit
+      end
+
+      desc = "Sets random seed. Also via env. Eg: SEED=n rake"
+      opts.on "-s", "--seed SEED", Integer, desc do |m|
+        options[:seed] = m.to_i
+      end
+
+      opts.on "-v", "--verbose", "Verbose. Show progress processing files." do
+        options[:verbose] = true
+      end
+
+      opts.on "-n", "--name PATTERN","Filter run on /pattern/ or string." do |a|
+        options[:filter] = a
+      end
+
+      unless extensions.empty?
+        opts.separator ""
+        opts.separator "Known extensions: #{extensions.join(', ')}"
+
+        extensions.each do |meth|
+          msg = "plugin_#{meth}_options"
+          send msg, opts, options if self.respond_to?(msg)
+        end
+      end
+
+      begin
+        opts.parse! args
+      rescue OptionParser::InvalidOption => e
+        puts
+        puts e
+        puts
+        puts opts
+        exit 1
+      end
+
+      orig_args -= args
+    end unless args.empty?
+
+    unless options[:seed] then
+      srand
+      options[:seed] = (ENV["SEED"] || srand).to_i % 0xFFFF
+      orig_args << "--seed" << options[:seed].to_s
+    end
+
+    srand options[:seed]
+
+    options[:args] = orig_args.map { |s|
+      s =~ /[\s|&<>$()]/ ? s.inspect : s
+    }.join " "
+
+    options
+  end
+
+  def self.filter_backtrace bt # :nodoc:
+    backtrace_filter.filter bt
+  end
+
+  ##
+  # Represents anything "runnable", like Test, Spec, Benchmark, or
+  # whatever you can dream up.
+  #
+  # Subclasses of this are automatically registered and available in
+  # Runnable.runnables.
+
+  class Runnable
+    ##
+    # Number of assertions executed in this run.
+
+    attr_accessor :assertions
+
+    ##
+    # An assertion raised during the run, if any.
+
+    attr_accessor :failures
+
+    ##
+    # Name of the run.
+
+    def name
+      @NAME
+    end
+
+    ##
+    # Set the name of the run.
+
+    def name= o
+      @NAME = o
+    end
+
+    def self.inherited klass # :nodoc:
+      self.runnables << klass
+      super
+    end
+
+    ##
+    # Returns all instance methods matching the pattern +re+.
+
+    def self.methods_matching re
+      public_instance_methods(true).grep(re).map(&:to_s)
+    end
+
+    def self.reset # :nodoc:
+      @@runnables = []
+    end
+
+    reset
+
+    ##
+    # Responsible for running all runnable methods in a given class,
+    # each in its own instance. Each instance is passed to the
+    # reporter to record.
+
+    def self.run reporter, options = {}
+      filter = options[:filter] || '/./'
+      filter = Regexp.new $1 if filter =~ /\/(.*)\//
+
+      filtered_methods = self.runnable_methods.find_all { |m|
+        filter === m || filter === "#{self}##{m}"
+      }
+
+      with_info_handler reporter do
+        filtered_methods.each do |method_name|
+          run_one_method self, method_name, reporter
+        end
+      end
+    end
+
+    ##
+    # Runs a single method and has the reporter record the result.
+    # This was considered internal API but is factored out of run so
+    # that subclasses can specialize the running of an individual
+    # test. See Minitest::ParallelTest::ClassMethods for an example.
+
+    def self.run_one_method klass, method_name, reporter
+      reporter.record Minitest.run_one_method(klass, method_name)
+    end
+
+    def self.with_info_handler reporter, &block # :nodoc:
+      handler = lambda do
+        unless reporter.passed? then
+          warn "Current results:"
+          warn ""
+          warn reporter.reporters.first
+          warn ""
+        end
+      end
+
+      on_signal "INFO", handler, &block
+    end
+
+    SIGNALS = {} # Signal.list # :nodoc:
+
+    def self.on_signal name, action # :nodoc:
+      supported = SIGNALS[name]
+
+      old_trap = trap name do
+        old_trap.call if old_trap.respond_to? :call
+        action.call
+      end if supported
+
+      yield
+    ensure
+      trap name, old_trap if supported
+    end
+
+    ##
+    # Each subclass of Runnable is responsible for overriding this
+    # method to return all runnable methods. See #methods_matching.
+
+    def self.runnable_methods
+      raise NotImplementedError, "subclass responsibility"
+    end
+
+    ##
+    # Returns all subclasses of Runnable.
+
+    def self.runnables
+      @@runnables
+    end
+
+    def marshal_dump # :nodoc:
+      [self.name, self.failures, self.assertions]
+    end
+
+    def marshal_load ary # :nodoc:
+      self.name, self.failures, self.assertions = ary
+    end
+
+    def failure # :nodoc:
+      self.failures.first
+    end
+
+    def initialize name # :nodoc:
+      self.name       = name
+      self.failures   = []
+      self.assertions = 0
+    end
+
+    ##
+    # Runs a single method. Needs to return self.
+
+    def run
+      raise NotImplementedError, "subclass responsibility"
+    end
+
+    ##
+    # Did this run pass?
+    #
+    # Note: skipped runs are not considered passing, but they don't
+    # cause the process to exit non-zero.
+
+    def passed?
+      raise NotImplementedError, "subclass responsibility"
+    end
+
+    ##
+    # Returns a single character string to print based on the result
+    # of the run. Eg ".", "F", or "E".
+
+    def result_code
+      raise NotImplementedError, "subclass responsibility"
+    end
+
+    ##
+    # Was this run skipped? See #passed? for more information.
+
+    def skipped?
+      raise NotImplementedError, "subclass responsibility"
+    end
+  end
+
+  ##
+  # Defines the API for Reporters. Subclass this and override whatever
+  # you want. Go nuts.
+
+  class AbstractReporter
+    # include Mutex_m
+
+    ##
+    # Starts reporting on the run.
+
+    def start
+    end
+
+    ##
+    # Record a result and output the Runnable#result_code. Stores the
+    # result of the run if the run did not pass.
+
+    def record result
+    end
+
+    ##
+    # Outputs the summary of the run.
+
+    def report
+    end
+
+    ##
+    # Did this run pass?
+
+    def passed?
+      true
+    end
+  end
+
+  class Reporter < AbstractReporter # :nodoc:
+    ##
+    # The IO used to report.
+
+    attr_accessor :io
+
+    ##
+    # Command-line options for this run.
+
+    attr_accessor :options
+
+    def initialize io = $stdout, options = {} # :nodoc:
+      super()
+      self.io      = io
+      self.options = options
+    end
+  end
+
+  ##
+  # A very simple reporter that prints the "dots" during the run.
+  #
+  # This is added to the top-level CompositeReporter at the start of
+  # the run. If you want to change the output of minitest via a
+  # plugin, pull this out of the composite and replace it with your
+  # own.
+
+  class ProgressReporter < Reporter
+    def record result # :nodoc:
+      io.print "%s#%s = %.2f s = " % [result.class, result.name, result.time] if
+        options[:verbose]
+      io.print result.result_code
+      io.puts if options[:verbose]
+    end
+  end
+
+  ##
+  # A reporter that gathers statistics about a test run. Does not do
+  # any IO because meant to be used as a parent class for a reporter
+  # that does.
+  #
+  # If you want to create an entirely different type of output (eg,
+  # CI, HTML, etc), this is the place to start.
+
+  class StatisticsReporter < Reporter
+    # :stopdoc:
+    attr_accessor :assertions
+    attr_accessor :count
+    attr_accessor :results
+    attr_accessor :start_time
+    attr_accessor :total_time
+    attr_accessor :failures
+    attr_accessor :errors
+    attr_accessor :skips
+    # :startdoc:
+
+    def initialize io = $stdout, options = {} # :nodoc:
+      super
+
+      self.assertions = 0
+      self.count      = 0
+      self.results    = []
+      self.start_time = nil
+      self.total_time = nil
+      self.failures   = nil
+      self.errors     = nil
+      self.skips      = nil
+    end
+
+    def passed? # :nodoc:
+      results.all?(&:skipped?)
+    end
+
+    def start # :nodoc:
+      self.start_time = Time.now
+    end
+
+    def record result # :nodoc:
+      self.count += 1
+      self.assertions += result.assertions
+
+      results << result if not result.passed? or result.skipped?
+    end
+
+    def report # :nodoc:
+      aggregate = results.group_by { |r| r.failure.class }
+      aggregate.default = [] # dumb. group_by should provide this
+
+      self.total_time = Time.now - start_time
+      self.failures   = aggregate[Assertion].size
+      self.errors     = aggregate[UnexpectedError].size
+      self.skips      = aggregate[Skip].size
+    end
+  end
+
+  ##
+  # A reporter that prints the header, summary, and failure details at
+  # the end of the run.
+  #
+  # This is added to the top-level CompositeReporter at the start of
+  # the run. If you want to change the output of minitest via a
+  # plugin, pull this out of the composite and replace it with your
+  # own.
+
+  class SummaryReporter < StatisticsReporter
+    # :stopdoc:
+    attr_accessor :sync
+    attr_accessor :old_sync
+    # :startdoc:
+
+    def start # :nodoc:
+      super
+
+      io.puts "Run options: #{options[:args]}"
+      io.puts
+      io.puts "# Running:"
+      io.puts
+
+      self.sync = io.respond_to? :"sync=" # stupid emacs
+      self.old_sync, io.sync = io.sync, true if self.sync
+    end
+
+    def report # :nodoc:
+      super
+
+      io.sync = self.old_sync
+
+      io.puts unless options[:verbose] # finish the dots
+      io.puts
+      io.puts statistics
+      io.puts aggregated_results
+      io.puts summary
+    end
+
+    def statistics # :nodoc:
+      "Finished in %.6fs, %.4f runs/s, %.4f assertions/s." %
+        [total_time, count / total_time, assertions / total_time]
+    end
+
+    def aggregated_results # :nodoc:
+      filtered_results = results.dup
+      filtered_results.reject!(&:skipped?) unless options[:verbose]
+
+      s = filtered_results.each_with_index.map { |result, i|
+        "\n%3d) %s" % [i+1, result]
+      }.join("\n") + "\n"
+
+      s.force_encoding(io.external_encoding) if
+        ENCS and io.external_encoding and s.encoding != io.external_encoding
+
+      s
+    end
+
+    alias to_s aggregated_results
+
+    def summary # :nodoc:
+      extra = ""
+
+      extra = "\n\nYou have skipped tests. Run with --verbose for details." if
+        results.any?(&:skipped?) unless options[:verbose] or ENV["MT_NO_SKIP_MSG"]
+
+      "%d runs, %d assertions, %d failures, %d errors, %d skips%s" %
+        [count, assertions, failures, errors, skips, extra]
+    end
+  end
+
+  ##
+  # Dispatch to multiple reporters as one.
+
+  class CompositeReporter < AbstractReporter
+    ##
+    # The list of reporters to dispatch to.
+
+    attr_accessor :reporters
+
+    def initialize *reporters # :nodoc:
+      super()
+      self.reporters = reporters
+    end
+
+    ##
+    # Add another reporter to the mix.
+
+    def << reporter
+      self.reporters << reporter
+    end
+
+    def passed? # :nodoc:
+      self.reporters.all?(&:passed?)
+    end
+
+    def start # :nodoc:
+      self.reporters.each(&:start)
+    end
+
+    def record result # :nodoc:
+      self.reporters.each do |reporter|
+        reporter.record result
+      end
+    end
+
+    def report # :nodoc:
+      self.reporters.each(&:report)
+    end
+  end
+
+  ##
+  # Represents run failures.
+
+  class Assertion < Exception
+    def error # :nodoc:
+      self
+    end
+
+    ##
+    # Where was this run before an assertion was raised?
+
+    def location
+      last_before_assertion = ""
+      self.backtrace.reverse_each do |s|
+        break if s =~ /in .(assert|refute|flunk|pass|fail|raise|must|wont)/
+        last_before_assertion = s
+      end
+      last_before_assertion.sub(/:in .*$/, "")
+    end
+
+    def result_code # :nodoc:
+      result_label[0, 1]
+    end
+
+    def result_label # :nodoc:
+      "Failure"
+    end
+  end
+
+  ##
+  # Assertion raised when skipping a run.
+
+  class Skip < Assertion
+    def result_label # :nodoc:
+      "Skipped"
+    end
+  end
+
+  ##
+  # Assertion wrapping an unexpected error that was raised during a run.
+
+  class UnexpectedError < Assertion
+    attr_accessor :exception # :nodoc:
+
+    def initialize exception # :nodoc:
+      super
+      self.exception = exception
+    end
+
+    def backtrace # :nodoc:
+      self.exception.backtrace
+    end
+
+    def error # :nodoc:
+      self.exception
+    end
+
+    def message # :nodoc:
+      bt = Minitest::filter_backtrace(self.backtrace).join "\n    "
+      "#{self.exception.class}: #{self.exception.message}\n    #{bt}"
+    end
+
+    def result_label # :nodoc:
+      "Error"
+    end
+  end
+
+  ##
+  # Provides a simple set of guards that you can use in your tests
+  # to skip execution if it is not applicable. These methods are
+  # mixed into Test as both instance and class methods so you
+  # can use them inside or outside of the test methods.
+  #
+  #   def test_something_for_mri
+  #     skip "bug 1234"  if jruby?
+  #     # ...
+  #   end
+  #
+  #   if windows? then
+  #     # ... lots of test methods ...
+  #   end
+
+  module Guard
+
+    ##
+    # Is this running on jruby?
+
+    def jruby? platform = RUBY_PLATFORM
+      "java" == platform
+    end
+
+    ##
+    # Is this running on maglev?
+
+    def maglev? platform = defined?(RUBY_ENGINE) && RUBY_ENGINE
+      "maglev" == platform
+    end
+
+    ##
+    # Is this running on mri?
+
+    def mri? platform = RUBY_DESCRIPTION
+      /^ruby/ =~ platform
+    end
+
+    ##
+    # Is this running on rubinius?
+
+    def rubinius? platform = defined?(RUBY_ENGINE) && RUBY_ENGINE
+      "rbx" == platform
+    end
+
+    ##
+    # Is this running on windows?
+
+    def windows? platform = RUBY_PLATFORM
+      /mswin|mingw/ =~ platform
+    end
+  end
+
+  class BacktraceFilter # :nodoc:
+    def filter bt
+      return ["No backtrace"] unless bt
+
+      return bt.dup if $DEBUG
+
+      new_bt = bt.take_while { |line| line !~ /lib\/minitest/ }
+      new_bt = bt.select     { |line| line !~ /lib\/minitest/ } if new_bt.empty?
+      new_bt = bt.dup                                           if new_bt.empty?
+
+      new_bt
+    end
+  end
+
+  self.backtrace_filter = BacktraceFilter.new
+
+  def self.run_one_method klass, method_name # :nodoc:
+    result = klass.new(method_name).run
+    raise "#{klass}#run _must_ return self" unless klass === result
+    result
+  end
+end
+
+require "minitest/test"