opal 1.1.1 → 1.2.0.beta1

data/spec/filters/unsupported/time.rb

@@ -123,6 +123,7 @@ opal_unsupported_filter "Time" do
   fails "Time#utc_offset returns the correct offset for US Eastern time zone around daylight savings time change"
   fails "Time#utc_offset returns the offset in seconds between the timezone of time and UTC"
   fails "Time#wday returns an integer representing the day of the week, 0..6, with Sunday being 0"
+  fails "Time#yday returns an integer representing the day of the year, 1..366" # Expected 117 == 116
   fails "Time#year returns the four digit year for a Time with a fixed offset"
   fails "Time#year returns the four digit year for a local Time as an Integer"
   fails "Time#zone Encoding.default_internal is set doesn't raise errors for a Time with a fixed offset"
@@ -201,4 +202,7 @@ opal_unsupported_filter "Time" do
   fails "Time.utc ignores fractional seconds if a passed fractional number of microseconds"
   fails "Time.utc ignores fractional seconds if a passed whole number of microseconds"
   fails "Time.utc returns subclass instances"
+  fails_badly "Marshal.load for a Time loads the zone" # Seasonal failure
+  fails_badly "Time#inspect formats the local time following the pattern 'yyyy-MM-dd HH:mm:ss Z'" # Seasonal failure
+  fails_badly "Time#to_s formats the local time following the pattern 'yyyy-MM-dd HH:mm:ss Z'" # Seasonal failure
 end

data/spec/lib/compiler_spec.rb

@@ -42,6 +42,22 @@ RSpec.describe Opal::Compiler do
     expect_compiled('"hello #{100}"').to include('"hello "', '100')
   end
 
+  it "should compile ruby ranges" do
+    expect_compiled('1..1').to include('$range(1, 1, false)')
+    expect_compiled('1...1').to include('$range(1, 1, true)')
+    expect_compiled('..1').to include('$range(nil, 1, false)')
+    expect_compiled('...1').to include('$range(nil, 1, true)')
+    expect_compiled('1..').to include('$range(1, nil, false)')
+    expect_compiled('1...').to include('$range(1, nil, true)')
+    # Following return Opal.range.$new instead of $range. Some also miss a space.
+    expect_compiled('nil..1').to include('(nil, 1, false)')
+    expect_compiled('nil...1').to include('(nil,1, true)')
+    expect_compiled('"a"..nil').to include('("a", nil, false)')
+    expect_compiled('"a"...nil').to include('("a",nil, true)')
+    expect_compiled('..nil').to include('(nil, nil, false)')
+    expect_compiled('...nil').to include('(nil,nil, true)')
+  end
+
   it "should compile method calls" do
     expect_compiled("self.inspect").to include("$inspect()")
     expect_compiled("self.map { |a| a + 10 }").to include("$map")

data/spec/lib/rewriters/forward_args_spec.rb

@@ -0,0 +1,61 @@
+require 'lib/spec_helper'
+require 'support/rewriters_helper'
+require 'opal/rewriters/forward_args'
+
+RSpec.describe Opal::Rewriters::ForwardArgs do
+  include RewritersHelper
+  extend  RewritersHelper
+
+  before(:each) { Opal::Rewriters::ForRewriter.reset_tmp_counter! }
+
+  correct_names = proc do |ast|
+    case ast
+    when Opal::AST::Node
+      ast.children.map do |i|
+        correct_names.(i)
+      end.yield_self { |children| s(ast.type, *children) }
+    when :fwd_rest
+      "$fwd_rest"
+    when :fwd_block
+      "$fwd_block"
+    else
+      ast
+    end
+  end
+
+  include_examples 'it rewrites source-to-AST', <<~ENDSOURCE, correct_names.(parse(<<~ENDDEST))
+    def forward(...)
+      other(...)
+    end
+  ENDSOURCE
+    def forward(*fwd_rest, &fwd_block)
+      other(*fwd_rest, &fwd_block)
+    end
+  ENDDEST
+
+  include_examples 'it rewrites source-to-AST', <<~ENDSOURCE, correct_names.(parse(<<~ENDDEST))
+    def forward(first_arg, ...)
+      other(first_arg, second_arg, ...)
+      other(other_arg, ...)
+      other(...)
+    end
+  ENDSOURCE
+    def forward(first_arg, *fwd_rest, &fwd_block)
+      other(first_arg, second_arg, *fwd_rest, &fwd_block)
+      other(other_arg, *fwd_rest, &fwd_block)
+      other(*fwd_rest, &fwd_block)
+    end
+  ENDDEST
+
+  # Not supported by the parser (nor by the rewriter which would have to rearrange the arguments)
+
+  # include_examples 'it rewrites source-to-AST', <<~ENDSOURCE, correct_names.(parse(<<~ENDDEST))
+  #   def forward(a:, ...)
+  #     other(...)
+  #   end
+  # ENDSOURCE
+  #   def forward(*fwd_rest, a:, &fwd_block)
+  #     other(*fwd_rest, &fwd_block)
+  #   end
+  # ENDDEST
+end

data/spec/lib/rewriters/logical_operator_assignment_spec.rb

@@ -57,7 +57,7 @@ RSpec.describe Opal::Rewriters::LogicalOperatorAssignment do
     end
 
     context 'class variable' do
-      include_examples 'it rewrites', '@@a ||= 1', '@@a = @@a || 1'
+      include_examples 'it rewrites', '@@a ||= 1', '@@a = defined?(@@a) ? (@@a || 1) : 1'
       include_examples 'it rewrites', '@@a &&= 1', '@@a = @@a && 1'
     end
 

data/spec/lib/rewriters/numblocks_spec.rb

@@ -0,0 +1,44 @@
+require 'lib/spec_helper'
+require 'support/rewriters_helper'
+require 'opal/rewriters/numblocks'
+
+RSpec.describe Opal::Rewriters::Numblocks do
+  include RewritersHelper
+  extend  RewritersHelper
+
+  before(:each) { Opal::Rewriters::ForRewriter.reset_tmp_counter! }
+
+  correct_names = proc do |ast|
+    case ast
+    when Opal::AST::Node
+      ast.children.map do |i|
+        correct_names.(i)
+      end.yield_self { |children| s(ast.type, *children) }
+    when :arg1 then :_1
+    when :arg2 then :_2
+    when :arg3 then :_3
+    else
+      ast
+    end
+  end
+
+  include_examples 'it rewrites source-to-AST', <<~ENDSOURCE, correct_names.(parse(<<~ENDDEST))
+    proc do
+      _1
+    end
+  ENDSOURCE
+    proc do |arg1|
+      arg1
+    end
+  ENDDEST
+
+  include_examples 'it rewrites source-to-AST', <<~ENDSOURCE, correct_names.(parse(<<~ENDDEST))
+    proc do
+      _3
+    end
+  ENDSOURCE
+    proc do |arg1, arg2, arg3|
+      arg3
+    end
+  ENDDEST
+end

data/spec/lib/rewriters/opal_engine_check_spec.rb

@@ -30,11 +30,11 @@ RSpec.describe Opal::Rewriters::OpalEngineCheck do
             s(:send, ruby_const_sexp, :==, opal_str_sexp)
           end
 
-          it 'replaces true branch with s(:nil)' do
+          it 'replaces the expression with the true branch' do
             expect_rewritten(
               s(:if, check, true_branch, false_branch)
             ).to eq(
-              s(:if, check, true_branch, s(:nil))
+              true_branch
             )
           end
         end
@@ -58,11 +58,11 @@ RSpec.describe Opal::Rewriters::OpalEngineCheck do
             s(:send, ruby_const_sexp, :!=, opal_str_sexp)
           end
 
-          it 'replaces true branch with s(:nil)' do
+          it 'replaces the expression with the false branch' do
             expect_rewritten(
               s(:if, check, true_branch, false_branch)
             ).to eq(
-              s(:if, check, s(:nil), false_branch)
+              false_branch
             )
           end
         end
@@ -79,6 +79,51 @@ RSpec.describe Opal::Rewriters::OpalEngineCheck do
           end
         end
       end
+
+      it 'supports nested blocks' do
+        expect_rewritten(
+          # if true
+          #   if RUBY_ENGINE == 'opal'
+          #     if RUBY_ENGINE == 'opal'
+          #       :a
+          #     end
+          #     if RUBY_ENGINE != 'opal'
+          #       :b
+          #     end
+          #   end
+          # end
+
+          s(:if,
+            s(:true),
+            s(:if,
+              s(:send, ruby_const_sexp, :==, opal_str_sexp),
+              s(:begin,
+                s(:if,
+                  s(:send, ruby_const_sexp, :==, opal_str_sexp),
+                  s(:sym, :a)
+                ),
+                s(:if,
+                  s(:send, ruby_const_sexp, :!=, opal_str_sexp),
+                  s(:sym, :b)
+                )
+              )
+            )
+          )
+        ).to eq(
+          # if true
+          #   :a
+          #   nil
+          # end
+
+          s(:if,
+            s(:true),
+            s(:begin,
+              s(:sym, :a),
+              s(:nil)
+            )
+          )
+        )
+      end
     end
   end
 end

data/spec/opal/core/language/forward_args_spec.rb

@@ -0,0 +1,53 @@
+describe "Forward arguments" do
+  it "forwards args, kwargs and blocks" do
+    def fwd_t1_pass1(...)
+      fwd_t1_pass2(...)
+    end
+
+    def fwd_t1_pass2(*args, **kwargs, &block)
+      [args.count, kwargs.count, block_given?]
+    end
+
+    fwd_t1_pass1(1, 2, 3, a: 1, b: 2).should == [3, 2, false]
+    fwd_t1_pass1(1, 2, &:itself).should == [2, 0, true]
+    fwd_t1_pass1(a: 1, b: 2).should == [0, 2, false]
+  end
+
+  it "supports forwarding with initial arguments (3.0 behavior)" do
+    def fwd_t2_pass1(initial, ...)
+      fwd_t2_pass2(0, initial + 1, ...)
+    end
+
+    def fwd_t2_pass2(a, b, c)
+      a + b + c
+    end
+
+    fwd_t2_pass1(2, 3).should == 6
+    error = nil
+    begin
+      fwd_t2_pass1(2, 3, 4) # Too many arguments passwd to fwd_t2_pass2
+    rescue ArgumentError
+      error = :ArgumentError
+    end
+    error.should == :ArgumentError
+  end
+
+  it "supports forwarding to multiple methods at once" do
+    def fwd_t3_pass1(...)
+      fwd_t3_pass2a(...) + fwd_t3_pass2b(...) + fwd_t3_pass2c(...)
+    end
+
+    def fwd_t3_pass2a(*args)
+      -2 * args.count
+    end
+    def fwd_t3_pass2b(*args)
+      1 * args.count
+    end
+    def fwd_t3_pass2c(*args)
+      0 * args.count
+    end
+
+    fwd_t3_pass1(0, 0, 0).should == -3
+    fwd_t3_pass1(0, 0).should == -2
+  end
+end

data/spec/opal/core/language/infinite_range_spec.rb

@@ -0,0 +1,13 @@
+describe "Infinite ranges" do
+  it "supports endless ranges" do
+    range = (10..)
+    range.begin.should == 10
+    range.end.should == nil
+  end
+
+  it "supports beginless ranges" do
+    range = (..10)
+    range.begin.should == nil
+    range.end.should == 10
+  end
+end

data/spec/opal/core/language/memoization_spec.rb

@@ -0,0 +1,16 @@
+describe "memoization" do
+  it "memoizes a value with complex internal logic" do
+    klass = Class.new do
+      def memoized_value(dependency: nil)
+        @memoized_value ||= begin
+                              return nil if dependency.nil?
+
+                              dependency.call
+                            end
+      end
+    end
+
+    expect(klass.new.memoized_value(dependency: proc { :value })).to eq :value
+    expect(klass.new.memoized_value).to eq nil
+  end
+end

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