opal 1.0.4 → 1.1.1

data/spec/opal/stdlib/native/alias_native_spec.rb

@@ -0,0 +1,27 @@
+require 'native'
+
+describe "Native.alias_native" do
+  it "refers to an attribute on @native" do
+    Class.new {
+      include Native::Wrapper
+
+      alias_native :a, :a
+    }.new(`{ a: 2 }`).a.should == 2
+  end
+
+  it "refers to an attribute on @native and calls it if it's a function" do
+    Class.new {
+      include Native::Wrapper
+
+      alias_native :a, :a
+    }.new(`{ a: function() { return 42; } }`).a.should == 42
+  end
+
+  it "defaults old to new" do
+    Class.new {
+      include Native::Wrapper
+
+      alias_native :a
+    }.new(`{ a: 42 }`).a.should == 42
+  end
+end

data/spec/opal/stdlib/native/array_spec.rb

@@ -0,0 +1,11 @@
+require 'native'
+
+describe Array do
+  describe '#to_n' do
+    it 'converts an array with native objects to a JS array' do
+      obj = [`{ key: 1 }`]
+      native = obj.to_n
+      `#{native}[0].key`.should == 1
+    end
+  end
+end

data/spec/opal/stdlib/native/date_spec.rb

@@ -0,0 +1,12 @@
+require 'native'
+require 'date'
+
+describe Date do
+  describe '#to_n' do
+    it 'returns native JS date object' do
+      date = Date.new(1984, 1, 24)
+      native = date.to_n
+      expect(`#{native}.toDateString()`).to eq 'Tue Jan 24 1984'
+    end
+  end
+end

data/spec/opal/stdlib/native/deprecated_include_spec.rb

@@ -0,0 +1,8 @@
+require 'native'
+
+describe "Native inclusion" do
+  it "is deprecated" do
+    Native.should_receive(:warn).with("Including ::Native is deprecated. Please include Native::Wrapper instead.")
+    Class.new { include Native }
+  end
+end

data/spec/opal/stdlib/native/each_spec.rb

@@ -0,0 +1,13 @@
+require 'native'
+
+describe "Native::Object#each" do
+  it "enumerates on object properties" do
+    Native(`{ a: 2, b: 3 }`).each {|name, value|
+      ((name == :a && value == 2) || (name == :b && value == 3)).should be_true
+    }
+  end
+
+  it "accesses the native when no block is given" do
+    Native(`{ a: 2, b: 3, each: function() { return 42; } }`).each.should == 42
+  end
+end

data/spec/opal/stdlib/native/element_reference_spec.rb

@@ -0,0 +1,16 @@
+require 'native'
+
+describe "Native::Object#[]" do
+  it "should return the same value for bridged classes" do
+    Native(`2`).should === 2
+    Native(`"lol"`).should === "lol"
+  end
+
+  it "should return functions as is" do
+    Native(`{ a: function(){} }`)[:a].should be_kind_of Proc
+  end
+
+  it "should wrap natives into a Native object" do
+    Native(`{ a: { b: 2 } }`)[:a][:b].should == 2
+  end
+end

data/spec/opal/stdlib/native/exposure_spec.rb

@@ -0,0 +1,33 @@
+require 'native'
+
+describe 'Native exposure' do
+  describe Class do
+    describe '#native_alias' do
+      it 'exposes a method to javascript' do
+        c = Class.new do
+          def ruby_method
+            :ruby
+          end
+
+          native_alias :rubyMethod, :ruby_method
+        end
+
+        `#{c.new}.rubyMethod()`.should == :ruby
+      end
+    end
+
+    describe '#native_class' do
+      it 'exposes a Class on the JS global object' do
+        c = Class.new do
+          def self.name
+            'Pippo'
+          end
+
+          native_class
+        end
+
+        `Pippo`.should == c
+      end
+    end
+  end
+end

data/spec/opal/stdlib/native/ext_spec.rb

@@ -0,0 +1,19 @@
+require 'native'
+
+describe Hash do
+  describe '#initialize' do
+    it "returns a hash with a nil value" do
+      h = Hash.new(`{a: null}`)
+      h[:a].should == nil
+    end
+  end
+
+  describe '#to_n' do
+    it "should return a js object representing hash" do
+      Hash.new({:a => 100, :b => 200}.to_n).should == {:a => 100, :b => 200}
+    end
+  end
+end
+
+describe "Hash#to_n" do
+end

data/spec/opal/stdlib/native/hash_spec.rb

@@ -0,0 +1,67 @@
+require 'native'
+
+describe Hash do
+  it 'turns a native JS object into a hash' do
+    obj = %x{
+      {
+        a: 1,
+        b: "two",
+        c: {
+          d: 1,
+        },
+        e: [
+          {
+            f: 'g',
+            h: [null],
+          },
+        ],
+      }
+    }
+
+    h = Hash.new(obj)
+    expected_hash = {
+      a: 1,
+      b: "two",
+      c: {
+        d: 1,
+      },
+      e: [
+        {
+          f: 'g',
+          h: [nil],
+        },
+      ],
+    }
+
+    expect(h).to eq(expected_hash)
+  end
+
+  it 'turns Object.create(null) JS objects into a hash' do
+    %x{
+      var obj = Object.create(null);
+      var foo = Object.create(null);
+      var bar = Object.create(null);
+      obj.foo = foo;
+      foo.bar = bar;
+      bar.baz = 'baz';
+    }
+    hash = Hash.new(`obj`)
+
+    expect(hash).to eq({ foo: { bar: { baz: 'baz' } } })
+  end
+
+  describe '#to_n' do
+    it 'converts a hash with native objects as values' do
+      obj = { 'a_key' => `{ key: 1 }` }
+      native = obj.to_n
+      `#{native}.a_key.key`.should == 1
+    end
+
+    it 'passes Ruby objects that cannot be converted' do
+      object = Object.new
+      hash = { foo: object }
+      native = hash.to_n
+      expect(`#{native}.foo`).to eq object
+    end
+  end
+end

data/spec/opal/stdlib/native/initialize_spec.rb

@@ -0,0 +1,17 @@
+require 'native'
+
+describe "Native#initialize" do
+  it "works when Native is included in a BasicObject" do
+    basic_class = Class.new(BasicObject)
+    basic_object = basic_class.new
+    lambda { basic_object.native? }.should raise_error(NoMethodError)
+
+    basic_class.send :include, Native
+    lambda { basic_class.new(`{}`) }.should_not raise_error
+  end
+
+  it "detects a non native object" do
+    object = Object.new
+    lambda { Native::Object.new(object) }.should raise_error(ArgumentError)
+  end
+end

data/spec/opal/stdlib/native/method_missing_spec.rb

@@ -0,0 +1,51 @@
+require 'native'
+
+describe "Native::Object#method_missing" do
+  it "should return values" do
+    Native(`{ a: 23 }`).a.should == 23
+    Native(`{ a: { b: 42 } }`).a.b.should == 42
+  end
+
+  it "should call functions" do
+    Native(`{ a: function() { return 42 } }`).a.should == 42
+  end
+
+  it "should pass the proper this to functions" do
+    %x{
+      function foo() {
+        this.baz = 42;
+      }
+
+      foo.prototype.bar = function () {
+        return this.baz;
+      }
+    }
+
+    obj = `new foo()`
+    Native(obj).bar.should == 42
+    Native(obj).baz = 23
+    Native(obj).bar.should == 23
+  end
+
+  it "should set values" do
+    var = `{}`
+
+    Native(var).a = 42
+    `#{var}.a`.should == 42
+    Native(var).a.should == 42
+  end
+
+  it "should pass the block as function" do
+    Native(`{ a: function(func) { return func(); } }`).a { 42 }.should == 42
+  end
+
+  it "should unwrap arguments" do
+    x = `{}`
+
+    Native(`{ a: function(a, b) { return a === b } }`).a(Native(x), x).should == true
+  end
+
+  it "should wrap result" do
+    Native(`{ a: function() { return {}; } }`).a.class.should == Native::Object
+  end
+end

data/spec/opal/stdlib/native/native_alias_spec.rb

@@ -0,0 +1,26 @@
+require 'native'
+
+describe "Class#native_alias" do
+  it "exposes a method to javascript without the '$' prefix" do
+    klass = Class.new {
+      def a
+        2
+      end
+
+      native_alias :a, :a
+    }
+    instance = klass.new
+    `instance.a()`.should == 2
+  end
+
+  it "raises if the aliased method isn't defined" do
+    Class.new do
+      lambda {
+        native_alias :a, :not_a_method
+      }.should raise_error(
+        NameError,
+        %r{undefined method `not_a_method' for class `#<Class:0x\w+>'}
+      )
+    end
+  end
+end

data/spec/opal/stdlib/native/native_class_spec.rb

@@ -0,0 +1,18 @@
+require 'native'
+
+describe "Class#native_class" do
+  class SomeClass
+  end
+
+  after {`delete Opal.global.SomeClass`}
+
+  it "adds current constant to the global JS object" do
+    SomeClass.native_class
+    `Opal.global.SomeClass`.should == SomeClass
+  end
+
+  it 'aliases Class#new to the unprefixed new method in JS world' do
+    SomeClass.native_class
+    `Opal.global.SomeClass["new"]()`.is_a?(SomeClass).should == true
+  end
+end

data/spec/opal/stdlib/native/native_module_spec.rb

@@ -0,0 +1,13 @@
+require 'native'
+
+describe "Module#native_module" do
+  module SomeModule
+  end
+
+  after {`delete Opal.global.SomeModule`}
+
+  it "adds current constant to the global JS object" do
+    SomeModule.native_module
+    `Opal.global.SomeModule`.should == SomeModule
+  end
+end

data/spec/opal/stdlib/native/native_reader_spec.rb

@@ -0,0 +1,22 @@
+require 'native'
+
+describe "Native.native_reader" do
+  it "refers to an attribute on @native" do
+    Class.new {
+      include Native::Wrapper
+
+      native_reader :a
+    }.new(`{ a: 2 }`).a.should == 2
+  end
+
+  it "uses multiple names" do
+    n = Class.new {
+      include Native::Wrapper
+
+      native_reader :a, :b
+    }.new(`{ a: 2, b: 3 }`)
+
+    n.a.should == 2
+    n.b.should == 3
+  end
+end

data/spec/opal/stdlib/native/native_writer_spec.rb

@@ -0,0 +1,30 @@
+require 'native'
+
+describe "Native.native_writer" do
+  it "refers to an attribute on @native" do
+    n = Class.new {
+      include Native::Wrapper
+
+      native_reader :a
+      native_writer :a
+    }.new(`{ a: 2 }`)
+
+    n.a = 4
+    n.a.should == 4
+  end
+
+  it "supports multiple names" do
+    n = Class.new {
+      include Native::Wrapper
+
+      native_reader :a, :b
+      native_writer :a, :b
+    }.new(`{ a: 2, b: 3 }`)
+
+    n.a = 4
+    n.b = 5
+
+    n.a.should == 4
+    n.b.should == 5
+  end
+end

data/spec/opal/stdlib/native/new_spec.rb

@@ -0,0 +1,92 @@
+require 'native'
+
+describe "Native()" do
+  it "should return nil for null or undefined" do
+    Native(`null`).should be_nil
+    Native(`undefined`).should be_nil
+  end
+
+  it "should return String" do
+    Native(`""`).should be_an_instance_of String
+  end
+
+  it "should return Integer" do
+    Native(`0`).should be_an_instance_of Number
+  end
+
+  it "should return Float" do
+    Native(`0.01`).should be_an_instance_of Float
+  end
+
+  it "should return Array" do
+    Native(`[]`).should be_an_instance_of Array
+  end
+
+  it "should return Native::Object" do
+    Native(`{}`).instance_of?(Native::Object).should be_true
+  end
+
+  it "should return Array of String" do
+    Native(`[""]`).first.should be_an_instance_of String
+  end
+
+  it "should return Array of Integer" do
+    Native(`[0]`).first.should be_an_instance_of Number
+  end
+
+  it "should return Array of Float" do
+    Native(`[0.01]`).first.should be_an_instance_of Float
+  end
+
+  it "should return Array of Array" do
+    Native(`[[]]`).first.should be_an_instance_of Array
+  end
+
+  it "should return Array of Native::Object" do
+    Native(`[{}]`).first.instance_of?(Native::Object).should be_true
+  end
+
+  it "should return Object with String" do
+    Native(`{"key": ""}`)["key"].should be_an_instance_of String
+  end
+
+  it "should return Object with Integer" do
+    Native(`{"key": 0}`)["key"].should be_an_instance_of Number
+  end
+
+  it "should return Object with Float" do
+    Native(`{"key": 0.01}`)["key"].should be_an_instance_of Float
+  end
+
+  it "should return Object with Array" do
+    Native(`{"key": []}`)["key"].should be_an_instance_of Array
+  end
+
+  it "should return Native::Object with Native::Object" do
+    Native(`{"key": {}}`)["key"].instance_of?(Native::Object).should be_true
+  end
+
+  it "should return Proc" do
+    Native(`function(){}`).should be_an_instance_of Proc
+  end
+
+  it "should return Proc that return String" do
+    Native(`function(){return ""}`).call.should be_an_instance_of String
+  end
+
+  it "should return Proc that return Integer" do
+    Native(`function(){return 0}`).call.should be_an_instance_of Integer
+  end
+
+  it "should return Proc that return Float" do
+    Native(`function(){return 0.01}`).call.should be_an_instance_of Float
+  end
+
+  it "should return Proc that return Array" do
+    Native(`function(){return []}`).call.should be_an_instance_of Array
+  end
+
+  it "should return Proc that return Native::Object" do
+    Native(`function(){return {}}`).call.instance_of?(Native::Object).should be_true
+  end
+end