opal 1.0.1 → 1.1.0.rc1

data/spec/opal/core/helpers_spec.rb

@@ -0,0 +1,14 @@
+require 'spec_helper'
+
+describe Opal do
+  context '.instance_variable_name!' do
+    it 'does not use regular expressions on Opal level, so $` stays the same' do
+      'some string' =~ /string/
+      post_match = $`
+
+      Opal.instance_variable_name!(:@ivar_name)
+
+      expect($`).to eq(post_match)
+    end
+  end
+end

data/spec/opal/core/iterable_props_spec.rb

@@ -0,0 +1,53 @@
+require 'spec_helper'
+
+describe 'Iterable props defined by Opal on core JS objects' do
+  %x{
+    function iterableKeysOf(obj) {
+      var result = [];
+
+      for (var key in obj) {
+        result.push(key);
+      }
+
+      return result;
+    }
+  }
+
+  it 'is empty for numbers' do
+    `iterableKeysOf(1)`.should == []
+  end
+
+  it 'is empty for strings' do
+    `iterableKeysOf('123')`.should == ['0', '1', '2'] # indexes, in JS they are iterable by default
+    `iterableKeysOf(new String('123'))`.should == ['0', '1', '2'] # indexes, in JS they are iterable by default
+  end
+
+  it 'is empty for plain objects' do
+    `iterableKeysOf({})`.should == []
+  end
+
+  it 'is empty for boolean' do
+    `iterableKeysOf(true)`.should == []
+    `iterableKeysOf(false)`.should == []
+  end
+
+  it 'is empty for regexp' do
+    `iterableKeysOf(/regexp/)`.should == []
+  end
+
+  it 'is empty for functions' do
+    `iterableKeysOf(function() {})`.should == []
+  end
+
+  it 'is empty for dates' do
+    `iterableKeysOf(new Date())`.should == []
+  end
+
+  it 'is empty for errors' do
+    `iterableKeysOf(new Error('message'))`.should == []
+  end
+
+  it 'is empty for Math' do
+    `iterableKeysOf(Math)`.should == []
+  end
+end

data/spec/opal/core/kernel/at_exit_spec.rb

@@ -0,0 +1,70 @@
+module KernelExit
+  extend self
+  attr_accessor :status, :original_proc, :proc, :out
+
+  self.original_proc = `Opal.exit`
+  self.proc = `function(status){ #{KernelExit.status = `status`} }`
+
+  def out_after_exit
+    `Opal.exit = #{proc}`
+    exit
+    out
+  ensure
+    `Opal.exit = #{original_proc}`
+  end
+
+  def reset!
+    self.out = []
+  end
+end
+
+describe "Kernel.at_exit" do
+  before { KernelExit.reset! }
+
+  def print(n)
+    KernelExit.out << n
+  end
+
+  it "runs after all other code" do
+    Kernel.at_exit {print 5}
+    print 6
+
+    KernelExit.out_after_exit.should == [6,5]
+  end
+
+  it "runs in reverse order of registration" do
+    at_exit {print 4}
+    at_exit {print 5}
+    print 6
+    at_exit {print 7}
+
+    KernelExit.out_after_exit.should == [6,7,5,4]
+  end
+
+  it "allows calling exit inside at_exit handler" do
+    at_exit {print 3}
+    at_exit {
+      print 4
+      exit
+      # print 5 # This one is added to out because Opal.exit doesn't actually exit
+    }
+    at_exit {print 6}
+
+    KernelExit.out_after_exit.should == [6,4,3]
+  end
+
+  # INCOMPLETE: the spec implementation is tricky here
+  # it "gives access to the last raised exception" do
+  #   begin
+  #     at_exit do
+  #       print $!.message
+  #     end
+  #     raise 'foo' rescue nil
+  #     p [:err, $!]
+  #   rescue
+  #   end
+  #
+  #   KernelExit.out_after_exit.should == ['foo']
+  # end
+
+end

data/spec/opal/core/kernel/freeze_spec.rb

@@ -0,0 +1,15 @@
+# No real support, just mocking
+
+describe "Kernel#freeze" do
+  it 'responds to #freeze and #frozen?' do
+    o = mock('o')
+    o.frozen?.should be_false
+    o.freeze
+    o.frozen?.should be_false
+  end
+
+  it "returns self" do
+    o = Object.new
+    o.freeze.should equal(o)
+  end
+end

data/spec/opal/core/kernel/instance_variables_spec.rb

@@ -0,0 +1,110 @@
+describe "Kernel#instance_variables" do
+  context 'for nil' do
+    it 'returns blank array' do
+      expect(nil.instance_variables).to eq([])
+    end
+  end
+
+  context 'for string' do
+    it 'returns blank array' do
+      expect(''.instance_variables).to eq([])
+    end
+  end
+
+  context 'for non-empty string' do
+    it 'returns blank array' do
+      expect('test'.instance_variables).to eq([])
+    end
+  end
+
+  context 'for hash' do
+    it 'returns blank array' do
+      expect({}.instance_variables).to eq([])
+    end
+
+    context 'for a hash with a default value' do
+      it 'returns a blank array' do
+        hash = Hash.new(0)
+        expect(hash.instance_variables).to eq([])
+      end
+    end
+
+    context 'for a hash with a default proc' do
+      it 'returns a blank array' do
+        hash = Hash.new { 0 }
+        expect(hash.instance_variables).to eq([])
+      end
+    end
+  end
+
+  context 'for non-empty hash' do
+    it 'returns blank array' do
+      expect({ 1 => 2 }.instance_variables).to eq([])
+    end
+  end
+
+  context 'for array' do
+    it 'returns blank array' do
+      expect([].instance_variables).to eq([])
+    end
+  end
+
+  context 'for non-empty array' do
+    it 'returns blank array' do
+      expect((1..20).to_a.instance_variables).to eq([])
+    end
+  end
+
+  context 'for object' do
+    it 'returns blank array' do
+      expect(Object.new.instance_variables).to eq([])
+    end
+  end
+
+  context 'cloned object' do
+    it 'returns same vars as source object' do
+      object = Object.new
+      expect(object.clone.instance_variables).to eq(object.instance_variables)
+    end
+  end
+
+  context 'for object with js keyword as instance variables' do
+    reserved_keywords = %w(
+      @constructor
+      @displayName
+      @__proto__
+      @__parent__
+      @__noSuchMethod__
+      @__count__
+      @hasOwnProperty
+      @valueOf
+    )
+
+    reserved_keywords.each do |ivar|
+      context "#{ivar} as instance variable name" do
+        it "returns non-escaped #{ivar} in instance_variables list" do
+          obj = Object.new
+          obj.instance_variable_set(ivar, 'value')
+
+          expect(obj.instance_variables).to eq([ivar])
+        end
+      end
+    end
+  end
+
+  context 'for a class' do
+    it 'returns blank array' do
+      expect(Class.new.instance_variables).to eq([])
+    end
+  end
+
+  context 'for a class with nested constant' do
+    class ClassWithConstantWithoutIvar
+      A = 1
+    end
+
+    it 'returns blank array' do
+      expect(ClassWithConstantWithoutIvar.instance_variables).to eq([])
+    end
+  end
+end

data/spec/opal/core/kernel/methods_spec.rb

@@ -0,0 +1,25 @@
+module MethodsSpecs
+  class Issue < Object
+    def unique_method_name
+    end
+  end
+
+  # Trigger stub generation
+  Issue.new.unique_method_name
+end
+
+describe "Kernel#methods" do
+  it "lists methods available on an object" do
+    Object.new.methods.include?("puts").should == true
+  end
+
+  it "lists only singleton methods if false is passed" do
+    o = Object.new
+    def o.foo; 123; end
+    o.methods(false).should == ["foo"]
+  end
+
+  it "ignores stub methods" do
+    Object.methods.include?(:unique_method_name).should be_false
+  end
+end

data/spec/opal/core/kernel/public_methods_spec.rb

@@ -0,0 +1,25 @@
+module PublicMethodsSpecs
+  class Parent
+    def parent_method
+    end
+  end
+
+  class Child < Parent
+    def child_method
+    end
+  end
+end
+
+describe "Kernel#public_methods" do
+  it "lists methods available on an object" do
+    child = PublicMethodsSpecs::Child.new
+    child.public_methods.include?("parent_method").should == true
+    child.public_methods.include?("child_method").should == true
+  end
+
+  it "lists only those methods in the receiver if false is passed" do
+    child = PublicMethodsSpecs::Child.new
+    def child.singular_method; 1123; end
+    child.public_methods(false).sort.should == ["child_method", "singular_method"]
+  end
+end

data/spec/opal/core/kernel/require_tree_spec.rb

@@ -0,0 +1,18 @@
+describe 'Kernel.require_tree' do
+  it 'loads all the files in a directory' do
+    $ScratchPad = []
+    require_tree '../fixtures/require_tree_files'
+
+    $ScratchPad.sort.should == ['file 1.rb', 'file 2.rb', 'file 3.rb', 'file 4.rb', 'file 5.rb',
+                                'nested 1.rb', 'nested 2.rb', 'other 1.rb']
+  end
+
+  it 'can be used with "."' do
+    $ScratchPad = []
+    require_relative '../fixtures/require_tree_with_dot/index'
+
+    $ScratchPad[0].should == 'index.rb-pre'
+    $ScratchPad[1...-1].sort.should == ['file 1.rb', 'file 2.rb', 'file 3.rb']
+    $ScratchPad[-1].should == 'index.rb-post'
+  end
+end

data/spec/opal/core/kernel/respond_to_spec.rb

@@ -0,0 +1,15 @@
+class RespondToSpecs
+  def foo
+  end
+end
+
+describe "Kernel#respond_to?" do
+  before :each do
+    @a = RespondToSpecs.new
+  end
+
+  it "returns false if a method exists, but is marked with a '$$stub' property" do
+    `#{@a}.$foo.$$stub = true`
+    @a.respond_to?(:foo).should be_false
+  end
+end

data/spec/opal/core/language/DATA/characters_support_spec.rb

@@ -0,0 +1,9 @@
+describe "characters support of the DATA contstant" do
+  it "supports all characters" do
+    DATA.read.should == "azAZ09`~!@#$%^&*(\n)_+{}\\|;:'\",<.>/?\n"
+  end
+end
+
+__END__
+azAZ09`~!@#$%^&*(
+)_+{}\|;:'",<.>/?

data/spec/opal/core/language/DATA/empty___END___spec.rb

@@ -0,0 +1,7 @@
+describe "empty __END__ section without trailing newline" do
+  it "returns an empty string" do
+    DATA.read.should == ""
+  end
+end
+
+__END__

data/spec/opal/core/language/DATA/multiple___END___spec.rb

@@ -0,0 +1,10 @@
+describe "DATA constant with multiple __END__ sections" do
+  it "returns everything after first __END__" do
+    DATA.read.should == "1\n__END__\n2\n"
+  end
+end
+
+__END__
+1
+__END__
+2

data/spec/opal/core/language/arguments/mlhs_arg_spec.rb

@@ -0,0 +1,18 @@
+describe 'mlhs argument' do
+  context 'when pased value is falsey in JS' do
+    it 'still returns it' do
+      p = ->((a)){ a }
+      p.call(false).should == false
+      p.call("").should == ""
+      p.call(0).should == 0
+    end
+  end
+
+  context 'when passed value == null' do
+    it 'replaces it with nil' do
+      p = ->((a)){ a }
+      p.call([`undefined`]).should == nil
+      p.call([`null`]).should == nil
+    end
+  end
+end

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

@@ -0,0 +1,9 @@
+describe "Keyword arguments" do
+  it 'works with keys that are reserved words in JS' do
+    o = Object.new
+    def o.foo(default:)
+      default
+    end
+    o.foo(default: :bar).should == :bar
+  end
+end

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

@@ -0,0 +1,16 @@
+require 'spec_helper'
+
+describe "numblocks" do
+  it "supports numblocks" do
+    [1,2,3].map { _1 * 2 }.should == [2,4,6]
+    [[1,2],[3,4]].map { _1 * _2 }.should == [2,12]
+  end
+
+  it "reports correct arity" do
+    proc { [_1, _2] + [_3] }.arity.should == 3
+  end
+
+  it "reports correct parameters" do
+    proc { [_1, _2] }.parameters.should == [[:opt, :_1], [:opt, :_2]]
+  end
+end

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

@@ -0,0 +1,7 @@
+describe 'Safe navigator' do
+  it "handles also null and undefined" do
+    [`null`, `undefined`].each do |value|
+      value&.unknown.should == nil
+    end
+  end
+end

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

@@ -0,0 +1,31 @@
+describe "The while expression" do
+  it "restarts the current iteration without reevaluating condition with redo" do
+    a = []
+    i = 0
+    j = 0
+    while (i+=1)<3
+      a << i
+      j+=1
+      redo if j<3
+      a << 5
+    end
+    a.should == [1, 1, 1, 5, 2, 5]
+  end
+
+  it "restarts the current iteration without evaluation the code below redo" do
+    a = []
+    i = 0
+    while true
+      i += 1
+      a << i
+      if i < 3
+        redo
+      else
+        break
+      end
+      a << 5 # should never get here
+    end
+    a.should == [1, 2, 3]
+  end
+
+end