opal 0.7.0.beta3 → 0.7.0.rc1

data/stdlib/minitest/hell.rb

@@ -0,0 +1,11 @@
+require "minitest/parallel"
+
+class Minitest::Test
+  class << self
+    alias :old_test_order :test_order # :nodoc:
+
+    def test_order # :nodoc:
+      :parallel
+    end
+  end
+end

data/stdlib/minitest/mock.rb

@@ -0,0 +1,220 @@
+class MockExpectationError < StandardError; end # :nodoc:
+
+module Minitest # :nodoc:
+
+  ##
+  # A simple and clean mock object framework.
+  #
+  # All mock objects are an instance of Mock
+
+  class Mock
+    alias :__respond_to? :respond_to?
+
+    overridden_methods = %w(
+      ===
+      inspect
+      object_id
+      public_send
+      respond_to_missing?
+      send
+      to_s
+    )
+
+    instance_methods.each do |m|
+      undef_method m unless overridden_methods.include?(m.to_s) || m =~ /^__/
+    end
+
+    overridden_methods.map(&:to_sym).each do |method_id|
+      define_method method_id do |*args, &b|
+        if @expected_calls.has_key? method_id then
+          method_missing(method_id, *args, &b)
+        else
+          super(*args, &b)
+        end
+      end
+    end
+
+    def initialize # :nodoc:
+      @expected_calls = Hash.new { |calls, name| calls[name] = [] }
+      @actual_calls   = Hash.new { |calls, name| calls[name] = [] }
+    end
+
+    ##
+    # Expect that method +name+ is called, optionally with +args+ or a
+    # +blk+, and returns +retval+.
+    #
+    #   @mock.expect(:meaning_of_life, 42)
+    #   @mock.meaning_of_life # => 42
+    #
+    #   @mock.expect(:do_something_with, true, [some_obj, true])
+    #   @mock.do_something_with(some_obj, true) # => true
+    #
+    #   @mock.expect(:do_something_else, true) do |a1, a2|
+    #     a1 == "buggs" && a2 == :bunny
+    #   end
+    #
+    # +args+ is compared to the expected args using case equality (ie, the
+    # '===' operator), allowing for less specific expectations.
+    #
+    #   @mock.expect(:uses_any_string, true, [String])
+    #   @mock.uses_any_string("foo") # => true
+    #   @mock.verify  # => true
+    #
+    #   @mock.expect(:uses_one_string, true, ["foo"])
+    #   @mock.uses_one_string("bar") # => true
+    #   @mock.verify  # => raises MockExpectationError
+
+    def expect(name, retval, args=[], &blk)
+      name = name.to_sym
+
+      if block_given?
+        raise ArgumentError, "args ignored when block given" unless args.empty?
+        @expected_calls[name] << { :retval => retval, :block => blk }
+      else
+        raise ArgumentError, "args must be an array" unless Array === args
+        @expected_calls[name] << { :retval => retval, :args => args }
+      end
+      self
+    end
+
+    def __call name, data # :nodoc:
+      case data
+      when Hash then
+        "#{name}(#{data[:args].inspect[1..-2]}) => #{data[:retval].inspect}"
+      else
+        data.map { |d| __call name, d }.join ", "
+      end
+    end
+
+    ##
+    # Verify that all methods were called as expected. Raises
+    # +MockExpectationError+ if the mock object was not called as
+    # expected.
+
+    def verify
+      @expected_calls.each do |name, calls|
+        calls.each do |expected|
+          msg1 = "expected #{__call name, expected}"
+          msg2 = "#{msg1}, got [#{__call name, @actual_calls[name]}]"
+
+          raise MockExpectationError, msg2 if
+            @actual_calls.has_key?(name) and
+            not @actual_calls[name].include?(expected)
+
+          raise MockExpectationError, msg1 unless
+            @actual_calls.has_key?(name) and
+            @actual_calls[name].include?(expected)
+        end
+      end
+      true
+    end
+
+    def method_missing(sym, *args, &block) # :nodoc:
+      unless @expected_calls.has_key?(sym) then
+        raise NoMethodError, "unmocked method %p, expected one of %p" %
+          [sym, @expected_calls.keys.sort_by(&:to_s)]
+      end
+
+      index = @actual_calls[sym].length
+      expected_call = @expected_calls[sym][index]
+
+      unless expected_call then
+        raise MockExpectationError, "No more expects available for %p: %p" %
+          [sym, args]
+      end
+
+      expected_args, retval, val_block =
+        expected_call.values_at(:args, :retval, :block)
+
+      if val_block then
+        raise MockExpectationError, "mocked method %p failed block w/ %p" %
+          [sym, args] unless val_block.call(*args, &block)
+
+        # keep "verify" happy
+        @actual_calls[sym] << expected_call
+        return retval
+      end
+
+      if expected_args.size != args.size then
+        raise ArgumentError, "mocked method %p expects %d arguments, got %d" %
+          [sym, expected_args.size, args.size]
+      end
+
+      fully_matched = expected_args.zip(args).all? { |mod, a|
+        mod === a or mod == a
+      }
+
+      unless fully_matched then
+        raise MockExpectationError, "mocked method %p called with unexpected arguments %p" %
+          [sym, args]
+      end
+
+      @actual_calls[sym] << {
+        :retval => retval,
+        :args => expected_args.zip(args).map { |mod, a| mod === a ? mod : a }
+      }
+
+      retval
+    end
+
+    def respond_to?(sym, include_private = false) # :nodoc:
+      return true if @expected_calls.has_key? sym.to_sym
+      return __respond_to?(sym, include_private)
+    end
+  end
+end
+
+class Object # :nodoc:
+
+  ##
+  # Add a temporary stubbed method replacing +name+ for the duration
+  # of the +block+. If +val_or_callable+ responds to #call, then it
+  # returns the result of calling it, otherwise returns the value
+  # as-is. If stubbed method yields a block, +block_args+ will be
+  # passed along. Cleans up the stub at the end of the +block+. The
+  # method +name+ must exist before stubbing.
+  #
+  #     def test_stale_eh
+  #       obj_under_test = Something.new
+  #       refute obj_under_test.stale?
+  #
+  #       Time.stub :now, Time.at(0) do
+  #         assert obj_under_test.stale?
+  #       end
+  #     end
+  #
+
+  def stub name, val_or_callable, *block_args, &block
+    new_name = "__minitest_stub__#{name}"
+
+    metaclass = class << self; self; end
+
+    if respond_to? name and not methods.map(&:to_s).include? name.to_s then
+      metaclass.send :define_method, name do |*args|
+        super(*args)
+      end
+    end
+
+    metaclass.send :alias_method, new_name, name
+
+    metaclass.send :define_method, name do |*args, &blk|
+
+      ret = if val_or_callable.respond_to? :call then
+        val_or_callable.call(*args)
+      else
+        val_or_callable
+      end
+
+      blk.call(*block_args) if blk
+
+      ret
+    end
+
+    yield self
+  ensure
+    metaclass.send :undef_method, name
+    metaclass.send :alias_method, name, new_name
+    metaclass.send :undef_method, new_name
+  end
+
+end

data/stdlib/minitest/parallel.rb

@@ -0,0 +1,65 @@
+module Minitest
+  module Parallel
+
+    ##
+    # The engine used to run multiple tests in parallel.
+
+    class Executor
+
+      ##
+      # The size of the pool of workers.
+
+      attr_reader :size
+
+      ##
+      # Create a parallel test executor of with +size+ workers.
+
+      def initialize size
+        @size  = size
+        @queue = Queue.new
+        # @pool  = size.times.map {
+        #   Thread.new(@queue) do |queue|
+        #     Thread.current.abort_on_exception = true
+        #     while job = queue.pop
+        #       klass, method, reporter = job
+        #       result = Minitest.run_one_method klass, method
+        #       reporter.synchronize { reporter.record result }
+        #     end
+        #   end
+        # }
+      end
+
+      ##
+      # Add a job to the queue
+
+      def << work; @queue << work; end
+
+      ##
+      # Shuts down the pool of workers by signalling them to quit and
+      # waiting for them all to finish what they're currently working
+      # on.
+
+      def shutdown
+        # size.times { @queue << nil }
+        # @pool.each(&:join)
+        @queue.each do |job|
+          klass, method, reporter = job
+          result = Minitest.run_one_method klass, method
+          reporter.record result
+          # reporter.synchronize { reporter.record result }
+        end
+      end
+    end
+
+    module Test
+      def _synchronize; Test.io_lock.synchronize { yield }; end # :nodoc:
+
+      module ClassMethods
+        def run_one_method klass, method_name, reporter # :nodoc:
+          Minitest.parallel_executor << [klass, method_name, reporter]
+        end
+        def test_order; :parallel; end # :nodoc:
+      end
+    end
+  end
+end

data/stdlib/minitest/pride.rb

@@ -0,0 +1,4 @@
+require "minitest"
+
+Minitest.load_plugins
+Minitest::PrideIO.pride!

data/stdlib/minitest/pride_plugin.rb

@@ -0,0 +1,142 @@
+require "minitest"
+
+module Minitest
+  def self.plugin_pride_options opts, options # :nodoc:
+    opts.on "-p", "--pride", "Pride. Show your testing pride!" do
+      PrideIO.pride!
+    end
+  end
+
+  def self.plugin_pride_init options # :nodoc:
+    if PrideIO.pride? then
+      klass = ENV["TERM"] =~ /^xterm|-256color$/ ? PrideLOL : PrideIO
+      io    = klass.new options[:io]
+
+      self.reporter.reporters.grep(Minitest::Reporter).each do |rep|
+        rep.io = io
+      end
+    end
+  end
+
+  ##
+  # Show your testing pride!
+
+  class PrideIO
+    ##
+    # Activate the pride plugin. Called from both -p option and minitest/pride
+
+    def self.pride!
+      @pride = true
+    end
+
+    ##
+    # Are we showing our testing pride?
+
+    def self.pride?
+      @pride ||= false
+    end
+
+    # Start an escape sequence
+    ESC = "\e["
+
+    # End the escape sequence
+    NND = "#{ESC}0m"
+
+    # The IO we're going to pipe through.
+    attr_reader :io
+
+    def initialize io # :nodoc:
+      @io = io
+      # stolen from /System/Library/Perl/5.10.0/Term/ANSIColor.pm
+      # also reference http://en.wikipedia.org/wiki/ANSI_escape_code
+      @colors ||= (31..36).to_a
+      @size   = @colors.size
+      @index  = 0
+    end
+
+    ##
+    # Wrap print to colorize the output.
+
+    def print o
+      case o
+      when "." then
+        io.print pride o
+      when "E", "F" then
+        io.print "#{ESC}41m#{ESC}37m#{o}#{NND}"
+      when "S" then
+        io.print pride o
+      else
+        io.print o
+      end
+    end
+
+    def puts(*o) # :nodoc:
+      o.map! { |s|
+        s.to_s.sub(/Finished/) {
+          @index = 0
+          'Fabulous run'.split(//).map { |c|
+            pride(c)
+          }.join
+        }
+      }
+
+      io.puts(*o)
+    end
+
+    ##
+    # Color a string.
+
+    def pride string
+      string = "*" if string == "."
+      c = @colors[@index % @size]
+      @index += 1
+      "#{ESC}#{c}m#{string}#{NND}"
+    end
+
+    def method_missing msg, *args # :nodoc:
+      io.send(msg, *args)
+    end
+  end
+
+  ##
+  # If you thought the PrideIO was colorful...
+  #
+  # (Inspired by lolcat, but with clean math)
+
+  class PrideLOL < PrideIO
+    PI_3 = Math::PI / 3 # :nodoc:
+
+    def initialize io # :nodoc:
+      # walk red, green, and blue around a circle separated by equal thirds.
+      #
+      # To visualize, type this into wolfram-alpha:
+      #
+      #   plot (3*sin(x)+3), (3*sin(x+2*pi/3)+3), (3*sin(x+4*pi/3)+3)
+
+      # 6 has wide pretty gradients. 3 == lolcat, about half the width
+      @colors = (0...(6 * 7)).map { |n|
+        n *= 1.0 / 6
+        r  = (3 * Math.sin(n           ) + 3).to_i
+        g  = (3 * Math.sin(n + 2 * PI_3) + 3).to_i
+        b  = (3 * Math.sin(n + 4 * PI_3) + 3).to_i
+
+        # Then we take rgb and encode them in a single number using base 6.
+        # For some mysterious reason, we add 16... to clear the bottom 4 bits?
+        # Yes... they're ugly.
+
+        36 * r + 6 * g + b + 16
+      }
+
+      super
+    end
+
+    ##
+    # Make the string even more colorful. Damnit.
+
+    def pride string
+      c = @colors[@index % @size]
+      @index += 1
+      "#{ESC}38;5;#{c}m#{string}#{NND}"
+    end
+  end
+end

data/stdlib/minitest/spec.rb

@@ -0,0 +1,310 @@
+require "minitest/test"
+
+class Module # :nodoc:
+  def infect_an_assertion meth, new_name, dont_flip = false # :nodoc:
+    # warn "%-22p -> %p %p" % [meth, new_name, dont_flip]
+    dont_flip = !!dont_flip
+    self.class_eval do
+      define_method(new_name) do |*args|
+        case
+        when dont_flip
+          Minitest::Spec.current.send(meth, self, *args)
+        when Proc === self
+          Minitest::Spec.current.send(meth, *args, &self)
+        else
+          Minitest::Spec.current.send(meth, args.first, self, *args[1..-1])
+        end
+      end
+    end
+
+    # <<-EOM
+    #   def #{new_name} *args
+    #     case
+    #     when #{dont_flip} then
+    #       Minitest::Spec.current.#{meth}(self, *args)
+    #     when Proc === self then
+    #       Minitest::Spec.current.#{meth}(*args, &self)
+    #     else
+    #       Minitest::Spec.current.#{meth}(args.first, self, *args[1..-1])
+    #     end
+    #   end
+    # EOM
+  end
+end
+
+module Kernel # :nodoc:
+  ##
+  # Describe a series of expectations for a given target +desc+.
+  #
+  # Defines a test class subclassing from either Minitest::Spec or
+  # from the surrounding describe's class. The surrounding class may
+  # subclass Minitest::Spec manually in order to easily share code:
+  #
+  #     class MySpec < Minitest::Spec
+  #       # ... shared code ...
+  #     end
+  #
+  #     class TestStuff < MySpec
+  #       it "does stuff" do
+  #         # shared code available here
+  #       end
+  #       describe "inner stuff" do
+  #         it "still does stuff" do
+  #           # ...and here
+  #         end
+  #       end
+  #     end
+  #
+  # For more information on getting started with writing specs, see:
+  #
+  # http://www.rubyinside.com/a-minitestspec-tutorial-elegant-spec-style-testing-that-comes-with-ruby-5354.html
+  #
+  # For some suggestions on how to improve your specs, try:
+  #
+  # http://betterspecs.org
+  #
+  # but do note that several items there are debatable or specific to
+  # rspec.
+  #
+  # For more information about expectations, see Minitest::Expectations.
+
+  def describe desc, *additional_desc, &block # :doc:
+    stack = Minitest::Spec.describe_stack
+    name  = [stack.last, desc, *additional_desc].compact.join("::")
+    sclas = stack.last || if Class === self && is_a?(Minitest::Spec::DSL) then
+                            self
+                          else
+                            Minitest::Spec.spec_type desc, *additional_desc
+                          end
+
+    cls = sclas.create name, desc
+
+    stack.push cls
+    cls.class_eval(&block)
+    stack.pop
+    cls
+  end
+  private :describe
+end
+
+##
+# Minitest::Spec -- The faster, better, less-magical spec framework!
+#
+# For a list of expectations, see Minitest::Expectations.
+
+class Minitest::Spec < Minitest::Test
+
+  def self.current # :nodoc:
+    Thread.current[:current_spec]
+  end
+
+  def initialize name # :nodoc:
+    super
+    Thread.current[:current_spec] = self
+  end
+
+  ##
+  # Oh look! A Minitest::Spec::DSL module! Eat your heart out DHH.
+
+  module DSL
+    ##
+    # Contains pairs of matchers and Spec classes to be used to
+    # calculate the superclass of a top-level describe. This allows for
+    # automatically customizable spec types.
+    #
+    # See: register_spec_type and spec_type
+
+    TYPES = [[//, Minitest::Spec]]
+
+    ##
+    # Register a new type of spec that matches the spec's description.
+    # This method can take either a Regexp and a spec class or a spec
+    # class and a block that takes the description and returns true if
+    # it matches.
+    #
+    # Eg:
+    #
+    #     register_spec_type(/Controller$/, Minitest::Spec::Rails)
+    #
+    # or:
+    #
+    #     register_spec_type(Minitest::Spec::RailsModel) do |desc|
+    #       desc.superclass == ActiveRecord::Base
+    #     end
+
+    def register_spec_type(*args, &block)
+      if block then
+        matcher, klass = block, args.first
+      else
+        matcher, klass = *args
+      end
+      TYPES.unshift [matcher, klass]
+    end
+
+    ##
+    # Figure out the spec class to use based on a spec's description. Eg:
+    #
+    #     spec_type("BlahController") # => Minitest::Spec::Rails
+
+    def spec_type desc, *additional
+      TYPES.find { |matcher, klass|
+        if matcher.respond_to? :call then
+          matcher.call desc, *additional
+        else
+          matcher === desc.to_s
+        end
+      }.last
+    end
+
+    def describe_stack # :nodoc:
+      Thread.current[:describe_stack] ||= []
+    end
+
+    ##
+    # Returns the children of this spec.
+
+    def children
+      @children ||= []
+    end
+
+    def nuke_test_methods! # :nodoc:
+      self.public_instance_methods.grep(/^test_/).each do |name|
+        self.send :undef_method, name
+      end
+    end
+
+    ##
+    # Define a 'before' action. Inherits the way normal methods should.
+    #
+    # NOTE: +type+ is ignored and is only there to make porting easier.
+    #
+    # Equivalent to Minitest::Test#setup.
+
+    def before type = nil, &block
+      define_method :setup do
+        super()
+        self.instance_eval(&block)
+      end
+    end
+
+    ##
+    # Define an 'after' action. Inherits the way normal methods should.
+    #
+    # NOTE: +type+ is ignored and is only there to make porting easier.
+    #
+    # Equivalent to Minitest::Test#teardown.
+
+    def after type = nil, &block
+      define_method :teardown do
+        self.instance_eval(&block)
+        super()
+      end
+    end
+
+    ##
+    # Define an expectation with name +desc+. Name gets morphed to a
+    # proper test method name. For some freakish reason, people who
+    # write specs don't like class inheritance, so this goes way out of
+    # its way to make sure that expectations aren't inherited.
+    #
+    # This is also aliased to #specify and doesn't require a +desc+ arg.
+    #
+    # Hint: If you _do_ want inheritance, use minitest/test. You can mix
+    # and match between assertions and expectations as much as you want.
+
+    def it desc = "anonymous", &block
+      block ||= proc { skip "(no tests defined)" }
+
+      @specs ||= 0
+      @specs += 1
+
+      name = "test_%04d_%s" % [ @specs, desc ]
+
+      undef_klasses = self.children.reject { |c| c.public_method_defined? name }
+
+      define_method name, &block
+
+      undef_klasses.each do |undef_klass|
+        undef_klass.send :undef_method, name
+      end
+
+      name
+    end
+
+    ##
+    # Essentially, define an accessor for +name+ with +block+.
+    #
+    # Why use let instead of def? I honestly don't know.
+
+    def let name, &block
+      name = name.to_s
+      pre, post = "let '#{name}' cannot ", ". Please use another name."
+      methods = Minitest::Spec.instance_methods.map(&:to_s) - %w[subject]
+      raise ArgumentError, "#{pre}begin with 'test'#{post}" if
+        name =~ /\Atest/
+      raise ArgumentError, "#{pre}override a method in Minitest::Spec#{post}" if
+        methods.include? name
+
+      define_method name do
+        @_memoized ||= {}
+        @_memoized.fetch(name) { |k| @_memoized[k] = instance_eval(&block) }
+      end
+    end
+
+    ##
+    # Another lazy man's accessor generator. Made even more lazy by
+    # setting the name for you to +subject+.
+
+    def subject &block
+      let :subject, &block
+    end
+
+    def create name, desc # :nodoc:
+      cls = Class.new(self) do
+        @name = name
+        @desc = desc
+
+        nuke_test_methods!
+      end
+
+      children << cls
+
+      cls
+    end
+
+    def name # :nodoc:
+      defined?(@name) ? @name : super
+    end
+
+    def to_s # :nodoc:
+      name # Can't alias due to 1.8.7, not sure why
+    end
+
+    # :stopdoc:
+    attr_reader :desc
+    alias :specify :it
+
+    module InstanceMethods
+      def before_setup
+        super
+        Thread.current[:current_spec] = self
+      end
+    end
+
+    def self.extended obj
+      obj.send :include, InstanceMethods
+    end
+
+    # :startdoc:
+  end
+
+  extend DSL
+
+  TYPES = DSL::TYPES # :nodoc:
+end
+
+require "minitest/expectations"
+
+class Object # :nodoc:
+  include Minitest::Expectations unless ENV["MT_NO_EXPECTATIONS"]
+end