opal 1.1.0 → 1.2.0

data/spec/opal/core/module_spec.rb

@@ -15,8 +15,30 @@ module ModuleSubclassIncludedSpec
   M2 = Module2.new
 end
 
-describe 'Module#included' do
-  it 'gets called in subclasses (regression for https://github.com/opal/opal/issues/1900)' do
+module ModuleCVarSpec
+  module Mod0
+    def cvar0; @@cvar; end
+    def cvarx0; @@cvarx ||= 5; end
+    def cvary0; @@cvary; 0; end
+    def cvarz0; @@cvarz = @@cvarz || 5; end
+  end
+
+  module Mod1
+    include Mod0
+    @@cvar = 10
+    def cvar1; @@cvar; end
+    def cvar1=(new); @@cvar=new; end
+  end
+
+  module Mod2
+    include Mod1
+    def cvar2; @@cvar; end
+    def cvar2=(new); @@cvar=new; end
+  end
+end
+
+describe 'Module' do
+  it '#included gets called in subclasses (regression for https://github.com/opal/opal/issues/1900)' do
     $ScratchPad = []
     klass = Class.new
     klass.include ::ModuleSubclassIncludedSpec::M0
@@ -24,4 +46,18 @@ describe 'Module#included' do
     klass.include ::ModuleSubclassIncludedSpec::M2
     $ScratchPad.should == ['A included', 'B included']
   end
+
+  it "can access ancestor's @@cvar" do
+    klass = Class.new
+    klass.include ::ModuleCVarSpec::Mod2
+    klass.new.cvar1.should == 10
+    klass.new.cvar2.should == 10
+    klass.new.cvar2 = 50
+    klass.new.cvar1.should == 50
+    klass.new.cvar2.should == 50
+    klass.new.cvarx0.should == 5
+    klass.new.cvary0.should == 0
+    ->{ klass.new.cvarz0 }.should raise_error NameError
+    ->{ klass.new.cvar0 }.should raise_error NameError
+  end
 end

data/spec/opal/core/number/to_i_spec.rb

@@ -0,0 +1,28 @@
+require 'spec_helper'
+
+describe 'Number#to_i' do
+  it "should not change huge number" do
+    1504642339053716000000.to_i.should == 1504642339053716000000
+  end
+
+  it "should not change negative huge number" do
+    -1504642339053716000000.to_i.should == -1504642339053716000000
+  end
+
+  it "equals Number#truncate(0) with huge number" do
+    1504642339053716000000.to_i.should == 1504642339053716000000.truncate(0)
+  end
+
+  it "should not change Infinity" do
+    `Infinity`.to_i.should == `Infinity`
+  end
+
+  it "should not change -Infinity" do
+    `-Infinity`.to_i.should == `-Infinity`
+  end
+
+  it "should not change NaN" do
+    x = `NaN`.to_i
+    `Number.isNaN(x)`.should be_true
+  end
+end

data/spec/opal/core/runtime/bridged_classes_spec.rb

@@ -121,3 +121,19 @@ describe 'Bridged classes in different modules' do
     @bridged.new.some_bridged_method.should == [4, 5, 6]
   end
 end
+
+
+describe "Invalid bridged classes" do
+  it "raises a TypeError when trying to extend with non-Class" do
+    error_msg = /superclass must be a Class/
+    -> { class TestClass < `""`;                  end }.should raise_error(TypeError, error_msg)
+    -> { class TestClass < `3`;                   end }.should raise_error(TypeError, error_msg)
+    -> { class TestClass < `true`;                end }.should raise_error(TypeError, error_msg)
+    -> { class TestClass < `Math`;                end }.should raise_error(TypeError, error_msg)
+    -> { class TestClass < `Object.create({})`;   end }.should raise_error(TypeError, error_msg)
+    -> { class TestClass < `Object.create(null)`; end }.should raise_error(TypeError, error_msg)
+    -> { class TestClass < Module.new;            end }.should raise_error(TypeError, error_msg)
+    -> { class TestClass < BasicObject.new;       end }.should raise_error(TypeError, error_msg)
+  end
+end
+

data/spec/opal/core/runtime/constants_spec.rb

@@ -4,9 +4,15 @@ module RuntimeFixtures
 
   class A::B
     module C
-
     end
   end
+
+  module ModuleB
+  end
+
+  module ModuleA
+    include ModuleB
+  end
 end
 
 describe "Constants access via .$$ with dots (regression for #1418)" do
@@ -14,3 +20,16 @@ describe "Constants access via .$$ with dots (regression for #1418)" do
     `Opal.Object.$$.RuntimeFixtures.$$.A.$$.B.$$.C`.should == RuntimeFixtures::A::B::C
   end
 end
+
+describe "Inclusion of modules" do
+  it "that have been included by other modules works" do
+    # here ClassC would have failed to be created due to a bug in Opal.append_features
+    module RuntimeFixtures
+      class ClassC
+        include ModuleA
+        include ModuleB
+      end
+    end
+    RuntimeFixtures::ClassC.new.class.should == RuntimeFixtures::ClassC
+  end
+end

data/spec/opal/core/string/subclassing_spec.rb

@@ -0,0 +1,16 @@
+require 'spec_helper'
+
+class MyStringSubclass < String
+  attr_reader :v
+  def initialize(s, v)
+    super(s)
+    @v = v
+  end
+end
+
+describe "String subclassing" do
+  it "should call initialize for subclasses" do
+    c = MyStringSubclass.new('s', 5)
+    [c, c.v].should == ['s', 5]
+  end
+end

data/spec/opal/core/string/unpack_spec.rb

@@ -0,0 +1,22 @@
+require 'spec_helper'
+
+describe 'String#unpack' do
+  it 'correctly unpacks with U* strings with latin-1 characters' do
+    'café'.unpack('U*').should == [99, 97, 102, 233]
+    [99, 97, 102, 233].pack('U*').unpack('U*').should == [99, 97, 102, 233]
+  end
+
+  it 'correctly unpacks with U* strings with latin-2 characters' do
+    'pół'.unpack('U*').should == [112, 243, 322]
+    [112, 243, 322].pack('U*').unpack('U*').should == [112, 243, 322]
+  end
+
+  it 'correctly unpacks with c* strings with latin-2 characters' do
+    'ść'.unpack('c*').should == [-59, -101, -60, -121]
+  end
+
+  it 'correctly unpacks with s* binary strings' do
+    "\xc8\x01".unpack('s*').should == [456]
+    [678].pack('s').unpack('s').should == [678]
+  end
+end

data/spec/opal/core/string_spec.rb

@@ -19,10 +19,10 @@ describe 'Encoding' do
       Encoding.find('ascii').should == Encoding::ASCII
       Encoding.find('US-ASCII').should == Encoding::ASCII
       Encoding.find('us-ascii').should == Encoding::ASCII
-      Encoding.find('ASCII-8BIT').should == Encoding::ASCII
-      Encoding.find('ascii-8bit').should == Encoding::ASCII
-      Encoding.find('BINARY').should == Encoding::ASCII
-      Encoding.find('binary').should == Encoding::ASCII
+      Encoding.find('ASCII-8BIT').should == Encoding::BINARY
+      Encoding.find('ascii-8bit').should == Encoding::BINARY
+      Encoding.find('BINARY').should == Encoding::BINARY
+      Encoding.find('binary').should == Encoding::BINARY
     end
   end
 end

data/spec/ruby_specs

@@ -106,6 +106,9 @@ ruby/core/marshal/minor_version_spec
 ruby/core/nil
 ruby/core/numeric
 
+ruby/core/objectspace
+ruby/core/objectspace/weakmap
+
 ruby/core/proc
 
 ruby/core/range
@@ -175,7 +178,7 @@ ruby/library/pathname
 !ruby/library/pathname/empty_spec
 !ruby/library/pathname/glob_spec
 ruby/library/pp
-ruby/library/securerandom/hex_spec
+ruby/library/securerandom
 ruby/library/set
 ruby/library/singleton
 ruby/library/stringio/each_line_spec

data/stdlib/json.rb

@@ -186,7 +186,9 @@ class Numeric
 end
 
 class String
-  alias to_json inspect
+  def to_json
+    `JSON.stringify(self)`
+  end
 end
 
 class Time

data/stdlib/promise/v1.rb

@@ -0,0 +1 @@
+require 'promise'

data/stdlib/promise/v2.rb

@@ -0,0 +1,386 @@
+# {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/v2'
+#
+# ## 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 = PromiseV2.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 = PromiseV2.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 = PromiseV2.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 {PromiseV2} 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
+#
+# {PromiseV2.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:
+#
+#     PromiseV2.when(get_json, get_json2).then |first, second|
+#       puts "got two json payloads: #{first}, #{second}"
+#     end
+#
+
+warn 'PromiseV2 is a technology preview, which means it may change its behavior ' \
+     'in the future until this warning is removed. If you are interested in this part, ' \
+     'please make sure you track the async/await/promises tag on Opal issues: ' \
+     'https://github.com/opal/opal/issues?q=label%3Aasync%2Fawait%2Fpromises'
+
+class PromiseV2 < `Promise`
+  class << self
+    def allocate
+      ok, fail = nil, nil
+
+      prom = `new self.$$constructor(function(_ok, _fail) { #{ok} = _ok; #{fail} = _fail; })`
+      prom.instance_variable_set(:@type, :opal)
+      prom.instance_variable_set(:@resolve_proc, ok)
+      prom.instance_variable_set(:@reject_proc, fail)
+      prom
+    end
+
+    def when(*promises)
+      promises = Array(promises.length == 1 ? promises.first : promises)
+      `Promise.all(#{promises})`.tap do |prom|
+        prom.instance_variable_set(:@type, :when)
+      end
+    end
+
+    alias all when
+
+    def all_resolved(*promises)
+      promises = Array(promises.length == 1 ? promises.first : promises)
+      `Promise.allResolved(#{promises})`.tap do |prom|
+        prom.instance_variable_set(:@type, :all_resolved)
+      end
+    end
+
+    def any(*promises)
+      promises = Array(promises.length == 1 ? promises.first : promises)
+      `Promise.any(#{promises})`.tap do |prom|
+        prom.instance_variable_set(:@type, :any)
+      end
+    end
+
+    def race(*promises)
+      promises = Array(promises.length == 1 ? promises.first : promises)
+      `Promise.race(#{promises})`.tap do |prom|
+        prom.instance_variable_set(:@type, :race)
+      end
+    end
+
+    def resolve(value = nil)
+      `Promise.resolve(#{value})`.tap do |prom|
+        prom.instance_variable_set(:@type, :resolve)
+        prom.instance_variable_set(:@realized, :resolve)
+        prom.instance_variable_set(:@value, value)
+      end
+    end
+    alias value resolve
+
+    def reject(value = nil)
+      `Promise.reject(#{value})`.tap do |prom|
+        prom.instance_variable_set(:@type, :reject)
+        prom.instance_variable_set(:@realized, :reject)
+        prom.instance_variable_set(:@value, value)
+      end
+    end
+    alias error reject
+  end
+
+  attr_reader :prev, :next
+
+  # Is this promise native to JavaScript? This means, that methods like resolve
+  # or reject won't be available.
+  def native?
+    @type != :opal
+  end
+
+  # Raise an exception when a non-JS-native method is called on a JS-native promise
+  def nativity_check!
+    raise ArgumentError, 'this promise is native to JavaScript' if native?
+  end
+
+  # Raise an exception when a non-JS-native method is called on a JS-native promise
+  # but permits some typed promises
+  def light_nativity_check!
+    return if %i[reject resolve trace always fail then].include? @type
+    raise ArgumentError, 'this promise is native to JavaScript' if native?
+  end
+
+  # Allow only one chain to be present, as needed by the previous implementation.
+  # This isn't a strict check - it's always possible on the JS side to chain a
+  # given block.
+  def there_can_be_only_one!
+    raise ArgumentError, 'a promise has already been chained' if @next && @next.any?
+  end
+
+  def gen_tracing_proc(passing, &block)
+    proc do |i|
+      res = passing.call(i)
+      yield(res)
+      res
+    end
+  end
+
+  def resolve(value = nil)
+    nativity_check!
+    raise ArgumentError, 'this promise was already resolved' if @realized
+    @value = value
+    @realized = :resolve
+    @resolve_proc.call(value)
+    self
+  end
+  alias resolve! resolve
+
+  def reject(value = nil)
+    nativity_check!
+    raise ArgumentError, 'this promise was already resolved' if @realized
+    @value = value
+    @realized = :reject
+    @reject_proc.call(value)
+    self
+  end
+  alias reject! reject
+
+  def then(&block)
+    prom = nil
+    blk = gen_tracing_proc(block) do |val|
+      prom.instance_variable_set(:@realized, :resolve)
+      prom.instance_variable_set(:@value, val)
+    end
+    prom = `self.then(#{blk})`
+    prom.instance_variable_set(:@prev, self)
+    prom.instance_variable_set(:@type, :then)
+    (@next ||= []) << prom
+    prom
+  end
+
+  def then!(&block)
+    there_can_be_only_one!
+    self.then(&block)
+  end
+
+  alias do then
+  alias do! then!
+
+  def fail(&block)
+    prom = nil
+    blk = gen_tracing_proc(block) do |val|
+      prom.instance_variable_set(:@realized, :resolve)
+      prom.instance_variable_set(:@value, val)
+    end
+    prom = `self.catch(#{blk})`
+    prom.instance_variable_set(:@prev, self)
+    prom.instance_variable_set(:@type, :fail)
+    (@next ||= []) << prom
+    prom
+  end
+
+  def fail!(&block)
+    there_can_be_only_one!
+    fail(&block)
+  end
+
+  alias rescue fail
+  alias catch fail
+  alias rescue! fail!
+  alias catch! fail!
+
+  def always(&block)
+    prom = nil
+    blk = gen_tracing_proc(block) do |val|
+      prom.instance_variable_set(:@realized, :resolve)
+      prom.instance_variable_set(:@value, val)
+    end
+    prom = `self.finally(#{blk})`
+    prom.instance_variable_set(:@prev, self)
+    prom.instance_variable_set(:@type, :always)
+    (@next ||= []) << prom
+    prom
+  end
+
+  def always!(&block)
+    there_can_be_only_one!
+    always(&block)
+  end
+
+  alias finally always
+  alias ensure always
+  alias finally! always!
+  alias ensure! always!
+
+  def trace(depth = nil, &block)
+    prom = self.then do
+      values = []
+      prom = self
+      while prom && (!depth || depth > 0)
+        val = nil
+        begin
+          val = prom.value
+        rescue ArgumentError
+          val = :native
+        end
+        values.unshift(val)
+        depth -= 1 if depth
+        prom = prom.prev
+      end
+      yield(*values)
+    end
+
+    prom.instance_variable_set(:@type, :trace)
+    prom
+  end
+
+  def trace!(*args, &block)
+    there_can_be_only_one!
+    trace(*args, &block)
+  end
+
+  def resolved?
+    light_nativity_check!
+    @realized == :resolve
+  end
+
+  def rejected?
+    light_nativity_check!
+    @realized == :reject
+  end
+
+  def realized?
+    light_nativity_check!
+    !@realized.nil?
+  end
+
+  def value
+    if resolved?
+      if PromiseV2 === @value
+        @value.value
+      else
+        @value
+      end
+    end
+  end
+
+  def error
+    light_nativity_check!
+    @value if rejected?
+  end
+
+  def and(*promises)
+    promises = promises.map do |i|
+      if PromiseV2 === i
+        i
+      else
+        PromiseV2.value(i)
+      end
+    end
+    PromiseV2.when(self, *promises).then do |a, *b|
+      [*a, *b]
+    end
+  end
+
+  def initialize(&block)
+    yield self if block_given?
+  end
+
+  alias to_n itself
+
+  def inspect
+    result = "#<#{self.class}"
+
+    if @type
+      result += ":#{@type}" unless %i[opal resolve reject].include? @type
+    else
+      result += ':native'
+    end
+
+    result += ":#{@realized}" if @realized
+    result += "(#{object_id})"
+
+    if @next && @next.any?
+      result += " >> #{@next.inspect}"
+    end
+
+    result += ": #{@value.inspect}" if @value
+    result += '>'
+
+    result
+  end
+end