opal 0.7.0.beta3 → 0.7.0.rc1

data/stdlib/minitest/test.rb

@@ -0,0 +1,293 @@
+require "minitest" unless defined? Minitest::Runnable
+
+module Minitest
+  ##
+  # Subclass Test to create your own tests. Typically you'll want a
+  # Test subclass per implementation class.
+  #
+  # See Minitest::Assertions
+
+  class Test < Runnable
+    require "minitest/assertions"
+    include Minitest::Assertions
+
+    PASSTHROUGH_EXCEPTIONS = [NoMemoryError, SignalException, # :nodoc:
+                              Interrupt, SystemExit]
+
+    class << self; attr_accessor :io_lock; end # :nodoc:
+    self.io_lock = Mutex.new
+
+    ##
+    # Call this at the top of your tests when you absolutely
+    # positively need to have ordered tests. In doing so, you're
+    # admitting that you suck and your tests are weak.
+
+    def self.i_suck_and_my_tests_are_order_dependent!
+      class << self
+        undef_method :test_order if method_defined? :test_order
+        define_method :test_order do :alpha end
+      end
+    end
+
+    ##
+    # Make diffs for this Test use #pretty_inspect so that diff
+    # in assert_equal can have more details. NOTE: this is much slower
+    # than the regular inspect but much more usable for complex
+    # objects.
+
+    def self.make_my_diffs_pretty!
+      require "pp"
+
+      define_method :mu_pp do |o|
+        o.pretty_inspect
+      end
+    end
+
+    ##
+    # Call this at the top of your tests when you want to run your
+    # tests in parallel. In doing so, you're admitting that you rule
+    # and your tests are awesome.
+
+    def self.parallelize_me!
+      include Minitest::Parallel::Test
+      extend Minitest::Parallel::Test::ClassMethods
+    end
+
+    ##
+    # Returns all instance methods starting with "test_". Based on
+    # #test_order, the methods are either sorted, randomized
+    # (default), or run in parallel.
+
+    def self.runnable_methods
+      methods = methods_matching(/^test_/)
+
+      case self.test_order
+      when :random, :parallel then
+        max = methods.size
+        methods.sort.sort_by { rand max }
+      when :alpha, :sorted then
+        methods.sort
+      else
+        raise "Unknown test_order: #{self.test_order.inspect}"
+      end
+    end
+
+    ##
+    # Defines the order to run tests (:random by default). Override
+    # this or use a convenience method to change it for your tests.
+
+    def self.test_order
+      :random
+    end
+
+    ##
+    # The time it took to run this test.
+
+    attr_accessor :time
+
+    def marshal_dump # :nodoc:
+      super << self.time
+    end
+
+    def marshal_load ary # :nodoc:
+      self.time = ary.pop
+      super
+    end
+
+    TEARDOWN_METHODS = %w{ before_teardown teardown after_teardown } # :nodoc:
+
+    ##
+    # Runs a single test with setup/teardown hooks.
+
+    def run
+      with_info_handler do
+        time_it do
+          capture_exceptions do
+            before_setup; setup; after_setup
+
+            self.send self.name
+          end
+
+          TEARDOWN_METHODS.each do |hook|
+            capture_exceptions do
+              self.send hook
+            end
+          end
+        end
+      end
+
+      self # per contract
+    end
+
+    ##
+    # Provides before/after hooks for setup and teardown. These are
+    # meant for library writers, NOT for regular test authors. See
+    # #before_setup for an example.
+
+    module LifecycleHooks
+
+      ##
+      # Runs before every test, before setup. This hook is meant for
+      # libraries to extend minitest. It is not meant to be used by
+      # test developers.
+      #
+      # As a simplistic example:
+      #
+      #   module MyMinitestPlugin
+      #     def before_setup
+      #       super
+      #       # ... stuff to do before setup is run
+      #     end
+      #
+      #     def after_setup
+      #       # ... stuff to do after setup is run
+      #       super
+      #     end
+      #
+      #     def before_teardown
+      #       super
+      #       # ... stuff to do before teardown is run
+      #     end
+      #
+      #     def after_teardown
+      #       # ... stuff to do after teardown is run
+      #       super
+      #     end
+      #   end
+      #
+      #   class MiniTest::Test
+      #     include MyMinitestPlugin
+      #   end
+
+      def before_setup; end
+
+      ##
+      # Runs before every test. Use this to set up before each test
+      # run.
+
+      def setup; end
+
+      ##
+      # Runs before every test, after setup. This hook is meant for
+      # libraries to extend minitest. It is not meant to be used by
+      # test developers.
+      #
+      # See #before_setup for an example.
+
+      def after_setup; end
+
+      ##
+      # Runs after every test, before teardown. This hook is meant for
+      # libraries to extend minitest. It is not meant to be used by
+      # test developers.
+      #
+      # See #before_setup for an example.
+
+      def before_teardown; end
+
+      ##
+      # Runs after every test. Use this to clean up after each test
+      # run.
+
+      def teardown; end
+
+      ##
+      # Runs after every test, after teardown. This hook is meant for
+      # libraries to extend minitest. It is not meant to be used by
+      # test developers.
+      #
+      # See #before_setup for an example.
+
+      def after_teardown; end
+    end # LifecycleHooks
+
+    def capture_exceptions # :nodoc:
+      begin
+        yield
+      # rescue *PASSTHROUGH_EXCEPTIONS
+      #   raise
+      # rescue Assertion => e
+      #   self.failures << e
+      # rescue Exception => e
+      #   self.failures << UnexpectedError.new(e)
+      rescue => e
+        case e
+        when *PASSTHROUGH_EXCEPTIONS
+        when Assertion then self.failures << e
+        when Exception then self.failures << UnexpectedError.new(e)
+        end
+      end
+    end
+
+    ##
+    # Did this run error?
+
+    def error?
+      self.failures.any? { |f| UnexpectedError === f }
+    end
+
+    ##
+    # The location identifier of this test.
+
+    def location
+      loc = " [#{self.failure.location}]" unless passed? or error?
+      "#{self.class}##{self.name}#{loc}"
+    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?
+      not self.failure
+    end
+
+    ##
+    # Returns ".", "F", or "E" based on the result of the run.
+
+    def result_code
+      self.failure and self.failure.result_code or "."
+    end
+
+    ##
+    # Was this run skipped?
+
+    def skipped?
+      self.failure and Skip === self.failure
+    end
+
+    def time_it # :nodoc:
+      t0 = Time.now
+
+      yield
+    ensure
+      self.time = Time.now - t0
+    end
+
+    def to_s # :nodoc:
+      return location if passed? and not skipped?
+
+      failures.map { |failure|
+        "#{failure.result_label}:\n#{self.location}:\n#{failure.message}\n"
+      }.join "\n"
+    end
+
+    def with_info_handler &block # :nodoc:
+      t0 = Time.now
+
+      handler = lambda do
+        warn "\nCurrent: %s#%s %.2fs" % [self.class, self.name, Time.now - t0]
+      end
+
+      self.class.on_signal "INFO", handler, &block
+    end
+
+    include LifecycleHooks
+    include Guard
+    extend Guard
+  end # Test
+end
+
+require "minitest/unit" unless defined?(MiniTest) # compatibility layer only

data/stdlib/minitest/unit.rb

@@ -0,0 +1,45 @@
+# :stopdoc:
+
+unless defined?(Minitest) then
+  # all of this crap is just to avoid circular requires and is only
+  # needed if a user requires "minitest/unit" directly instead of
+  # "minitest/autorun", so we also warn
+
+  from = caller.reject { |s| s =~ /rubygems/ }.join("\n  ")
+  warn "Warning: you should require 'minitest/autorun' instead."
+  warn %(Warning: or add 'gem "minitest"' before 'require "minitest/autorun"')
+  warn "From:\n  #{from}"
+
+  module Minitest; end
+  MiniTest = Minitest # prevents minitest.rb from requiring back to us
+  require "minitest"
+end
+
+MiniTest = Minitest unless defined?(MiniTest)
+
+module Minitest
+  class Unit
+    VERSION = Minitest::VERSION
+    class TestCase < Minitest::Test
+      def self.inherited klass # :nodoc:
+        from = caller.first
+        warn "MiniTest::Unit::TestCase is now Minitest::Test. From #{from}"
+        super
+      end
+    end
+
+    def self.autorun # :nodoc:
+      from = caller.first
+      warn "MiniTest::Unit.autorun is now Minitest.autorun. From #{from}"
+      Minitest.autorun
+    end
+
+    def self.after_tests(&b)
+      from = caller.first
+      warn "MiniTest::Unit.after_tests is now Minitest.after_run. From #{from}"
+      Minitest.after_run(&b)
+    end
+  end
+end
+
+# :startdoc:

data/stdlib/native.rb

@@ -538,11 +538,20 @@ class Module
 end
 
 class Class
-  def native_alias(jsid, mid)
-    `#{self}.$$proto[#{jsid}] = #{self}.$$proto['$' + #{mid}]`
+  def native_alias(new_jsid, existing_mid)
+    %x{
+      var aliased = #{self}.$$proto['$' + #{existing_mid}];
+      if (!aliased) {
+        #{raise NameError, "undefined method `#{existing_mid}' for class `#{inspect}'"};
+      }
+      #{self}.$$proto[#{new_jsid}] = aliased;
+    }
   end
 
-  alias native_class native_module
+  def native_class
+    native_module
+    `self.new = self.$new;`
+  end
 end
 
 # native global

data/stdlib/nodejs/process.rb

@@ -1,6 +1,20 @@
 module Kernel
-  def exit(status)
-    `process.exit(status)`
+  def exit(status = true)
+    $__at_exit__.reverse.each(&:call) if $__at_exit__
+    `process.exit(status === true ? 0 : status)`
+  end
+
+  def caller
+    %x{
+      var stack;
+      try {
+        var err = Error("my error");
+        throw err;
+      } catch(e) {
+        stack = e.stack;
+      }
+      return stack.$split("\n").slice(3);
+    }
   end
 end
 

data/stdlib/promise.rb

@@ -1,3 +1,102 @@
+# {Promise} is used to help structure asynchronous code.
+#
+# It is available in the Opal standard library, and can be required in any Opal
+# application:
+#
+#     require 'promise'
+#
+# ## Basic Usage
+#
+# Promises are created and returned as objects with the assumption that they
+# will eventually be resolved or rejected, but never both. A {Promise} has
+# a {#then} and {#fail} method (or one of their aliases) that can be used to
+# register a block that gets called once resolved or rejected.
+#
+#     promise = Promise.new
+#
+#     promise.then {
+#       puts "resolved!"
+#     }.fail {
+#       puts "rejected!"
+#     }
+#
+#     # some time later
+#     promise.resolve
+#
+#     # => "resolved!"
+#
+# It is important to remember that a promise can only be resolved or rejected
+# once, so the block will only ever be called once (or not at all).
+#
+# ## Resolving Promises
+#
+# To resolve a promise, means to inform the {Promise} that it has succeeded
+# or evaluated to a useful value. {#resolve} can be passed a value which is
+# then passed into the block handler:
+#
+#     def get_json
+#       promise = Promise.new
+#
+#       HTTP.get("some_url") do |req|
+#         promise.resolve req.json
+#       end
+#
+#       promise
+#     end
+#
+#     get_json.then do |json|
+#       puts "got some JSON from server"
+#     end
+#
+# ## Rejecting Promises
+#
+# Promises are also designed to handle error cases, or situations where an
+# outcome is not as expected. Taking the previous example, we can also pass
+# a value to a {#reject} call, which passes that object to the registered
+# {#fail} handler:
+#
+#     def get_json
+#       promise = Promise.new
+#
+#       HTTP.get("some_url") do |req|
+#         if req.ok?
+#           promise.resolve req.json
+#         else
+#           promise.reject req
+#         end
+#
+#       promise
+#     end
+#
+#     get_json.then {
+#       # ...
+#     }.fail { |req|
+#       puts "it went wrong: #{req.message}"
+#     }
+#
+# ## Chaining Promises
+#
+# Promises become even more useful when chained together. Each {#then} or
+# {#fail} call returns a new {Promise} which can be used to chain more and more
+# handlers together.
+#
+#     promise.then { wait_for_something }.then { do_something_else }
+#
+# Rejections are propagated through the entire chain, so a "catch all" handler
+# can be attached at the end of the tail:
+#
+#     promise.then { ... }.then { ... }.fail { ... }
+#
+# ## Composing Promises
+#
+# {Promise.when} can be used to wait for more than one promise to resolve (or
+# reject). Using the previous example, we could request two different json
+# requests and wait for both to finish:
+#
+#     Promise.when(get_json, get_json2).then |first, second|
+#       puts "got two json payloads: #{first}, #{second}"
+#     end
+#
 class Promise
   def self.value(value)
     new.resolve(value)