opal 0.11.0.rc1 → 0.11.0

data/spec/opal/core/string_spec.rb

@@ -1,32 +0,0 @@
-require 'spec_helper'
-
-describe "String" do
-  it "handles contiguous parts correctly" do
-    str = "a" "b"
-    str.should == "ab"
-
-    str2 = "d" "#{str}"
-    str2.should == "dab"
-  end
-
-  it 'parses complex heredoc (pr #1363)' do
-    str = <<'...end ruby23.y/module_eval...'
-
-  def version
-    23
-  end
-
-  def default_encoding
-    Encoding::UTF_8
-  end
-...end ruby23.y/module_eval...
-
-    str.should == "\n  def version\n    23\n  end\n\n  def default_encoding\n    Encoding::UTF_8\n  end\n"
-  end
-end
-
-describe "String#tr" do
-  it 'regression for: https://github.com/opal/opal/issues/1386' do
-    'YWE/'.tr('+/', '-_').should == 'YWE_'
-  end
-end

data/spec/opal/core/time_spec.rb

@@ -1,38 +0,0 @@
-require 'spec_helper'
-require 'time'
-
-# rubyspec does not have specs for these listed methods
-describe Time do
-  describe '<=>' do
-    it 'returns -1 when self is less than other' do
-      (Time.new(2015, 1, 1) <=> Time.new(2015, 1, 2)).should == -1
-    end
-
-    it 'returns 0 when self is equal to other' do
-      (Time.new(2015, 1, 1) <=> Time.new(2015, 1, 1)).should == 0
-    end
-
-    it 'returns 1 when self is greater than other' do
-      (Time.new(2015, 1, 2) <=> Time.new(2015, 1, 1)).should == 1
-    end
-
-    it 'returns nil when compared to non-Time objects' do
-      (Time.new <=> nil).should == nil
-    end
-  end
-
-  describe "#==" do
-    it "returns true if self is equal to other date" do
-      (Time.new(2013, 9, 13) == Time.new(2013, 9, 13)).should == true
-    end
-
-    it "returns false if self is not equal to other date" do
-      (Time.new(2013, 10, 2) == Time.new(2013, 10, 11)).should == false
-    end
-
-    it 'returns false when compared to non-Time objects' do
-      (Time.new == nil).should == false
-      (Time.new == Object.new).should == false
-    end
-  end
-end

data/spec/opal/javascript_api_spec.rb

@@ -1,16 +0,0 @@
-module JavaScriptAPIFixtures
-  class A
-  end
-
-  class A::B
-  end
-end
-
-require 'spec_helper'
-require 'native'
-
-describe "JavaScript API" do
-  it "allows to acces scopes on `Opal` with dots (regression for #1418)" do
-    `Opal.JavaScriptAPIFixtures.A.B`.should == JavaScriptAPIFixtures::A::B
-  end
-end

data/spec/opal/stdlib/erb/erb_spec.rb

@@ -1,30 +0,0 @@
-require 'erb'
-require File.expand_path('../simple', __FILE__)
-require File.expand_path('../quoted', __FILE__)
-require File.expand_path('../inline_block', __FILE__)
-
-describe "ERB files" do
-  before :each do
-    @simple = Template['opal/stdlib/erb/simple']
-    @quoted = Template['opal/stdlib/erb/quoted']
-    @inline_block = Template['opal/stdlib/erb/inline_block']
-  end
-
-  it "should be defined by their filename on Template namespace" do
-    @simple.should be_kind_of(Template)
-  end
-
-  it "calling the block with a context should render the block" do
-    @some_data = "hello"
-    @simple.render(self).should == "<div>hello</div>\n"
-  end
-
-  it "should accept quotes in strings" do
-    @name = "adam"
-    @quoted.render(self).should == "<div class=\"foo\">hello there adam</div>\n"
-  end
-
-  it "should be able to handle inline blocks" do
-    @inline_block.should be_kind_of(Template)
-  end
-end

data/spec/opal/stdlib/erb/inline_block.opalerb

@@ -1,3 +0,0 @@
-<%= some_helper do %>
-  <h1>Hi there</h1>
-<% end %>

data/spec/opal/stdlib/erb/quoted.opalerb

@@ -1 +0,0 @@
-<div class="foo">hello <%= "there" + " #{@name}" %></div>

data/spec/opal/stdlib/erb/simple.opalerb

@@ -1 +0,0 @@
-<div><%= @some_data %></div>

data/spec/opal/stdlib/js_spec.rb

@@ -1,66 +0,0 @@
-require 'spec_helper'
-require 'js'
-
-describe 'javascript operations using JS module' do
-  it 'JS.typeof uses typeof to return underlying javascript type' do
-    [1, `null`, `undefined`, Object.new, [], ""].each do |v|
-      JS.typeof(v).should == `typeof #{v}`
-    end
-  end
-
-  it 'JS.new uses new to create new instance' do
-    f = `function(){}`
-    f.JS[:prototype].JS[:color] = 'black'
-    JS.new(f).JS[:color].should == 'black'
-  end
-
-  it 'JS.new handles blocks' do
-    f = `function(a){this.a = a}`
-    JS.new(f){1}.JS.a.should == 1
-  end
-
-  it 'JS.instanceof uses instanceof to check if value is an instance of a function' do
-    f = `function(){}`
-    JS.instanceof(JS.new(f), f).should == true
-    JS.instanceof(JS.new(f), `function(){}`).should == false
-  end
-
-  it 'JS.delete uses delete to remove properties from objects' do
-    f = `{a:1}`
-    f.JS[:a].should == 1
-    JS.delete(f, :a)
-    `#{f.JS[:a]} === undefined`.should == true
-  end
-
-  it 'JS.in uses in to check for properties in objects' do
-    f = `{a:1}`
-    JS.in(:a, f).should == true
-    JS.in(:b, f).should == false
-  end
-
-  it 'JS.void returns undefined' do
-    f = 1
-    `#{JS.void(f += 1)} === undefined`.should == true
-    f.should == 2
-  end
-
-  it 'JS.call calls global javascript methods' do
-    JS.call(:parseFloat, '1.0').should == 1
-    JS.call(:parseInt, '1').should == 1
-    JS.call(:eval, "({a:1})").JS[:a].should == 1
-  end
-
-  it 'JS.method_missing calls global javascript methods' do
-    JS.parseFloat('1.0').should == 1
-    JS.parseInt('1').should == 1
-  end
-
-  it 'JS.call calls global javascript methods with blocks' do
-    begin
-      JS.global.JS[:_test_global_function] = lambda{|pr| pr.call + 1}
-      JS._test_global_function{1}.should == 2
-    ensure
-      JS.delete(JS.global, :_test_global_function)
-    end
-  end
-end

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

@@ -1,48 +0,0 @@
-require 'json'
-
-describe "Hash#to_json" do
-  it "returns a string of all key and value pairs" do
-    {}.to_json.should == "{}"
-    {"a" => 1, "b" => 2}.to_json.should == '{"a":1, "b":2}'
-
-    hash = {"a" => 1, "b" => false, "c" => nil, "d" => true}
-    JSON.parse(hash.to_json).should == hash
-  end
-end
-
-describe "Array#to_json" do
-  it "returns a string of all array elements converted to json" do
-    [].to_json.should == "[]"
-    [1, 2, 3].to_json.should == "[1, 2, 3]"
-    [true, nil, false, "3", 42].to_json.should == '[true, null, false, "3", 42]'
-  end
-end
-
-describe "Boolean#to_json" do
-  it "returns 'true' when true" do
-    true.to_json.should == "true"
-  end
-
-  it "returns 'false' when false" do
-    false.to_json.should == "false"
-  end
-end
-
-describe "Kernel#to_json" do
-  it "returns an escaped #to_s of the receiver" do
-    self.to_json.should be_kind_of(String)
-  end
-end
-
-describe "NilClass#to_json" do
-  it "returns 'null'" do
-    nil.to_json.should == "null"
-  end
-end
-
-describe "String#to_json" do
-  it "returns an escaped string" do
-    "foo".to_json.should == "\"foo\""
-    "bar\nbaz".to_json.should == "\"bar\\nbaz\""
-  end
-end

data/spec/opal/stdlib/json/parse_spec.rb

@@ -1,37 +0,0 @@
-require 'json'
-
-describe "JSON.parse" do
-  it "parses null into nil" do
-    JSON.parse("null").should be_nil
-  end
-
-  it "parses true into true" do
-    JSON.parse("true").should be_true
-  end
-
-  it "parses false into false" do
-    JSON.parse("false").should be_false
-  end
-
-  it "parses numbers into numbers" do
-    JSON.parse("42").should == 42
-    JSON.parse("3.142").should == 3.142
-  end
-
-  it "parses arrays into ruby arrays" do
-    JSON.parse("[]").should == []
-    JSON.parse("[1, 2, 3]").should == [1, 2, 3]
-    JSON.parse("[[1, 2, 3], [4, 5]]").should == [[1, 2, 3], [4, 5]]
-    JSON.parse("[null, true, false]").should == [nil, true, false]
-  end
-
-  it "parses object literals into ruby hashes" do
-    JSON.parse("{}").should == {}
-    JSON.parse('{"a": "b"}').should == {"a" => "b"}
-    JSON.parse('{"a": null, "b": 10, "c": [true, false]}').should == {"a" => nil, "b" => 10, "c" => [true, false]}
-  end
-
-  it "raises ParserError for invalid JSON" do
-    lambda { JSON.parse("invalid_json") }.should raise_error(JSON::ParserError)
-  end
-end

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

@@ -1,27 +0,0 @@
-require 'native'
-
-describe "Native.alias_native" do
-  it "refers to an attribute on @native" do
-    Class.new {
-      include Native
-
-      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
-
-      alias_native :a, :a
-    }.new(`{ a: function() { return 42; } }`).a.should == 42
-  end
-
-  it "defaults old to new" do
-    Class.new {
-      include Native
-
-      alias_native :a
-    }.new(`{ a: 42 }`).a.should == 42
-  end
-end

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

@@ -1,11 +0,0 @@
-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/each_spec.rb

@@ -1,13 +0,0 @@
-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

@@ -1,16 +0,0 @@
-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

@@ -1,33 +0,0 @@
-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

@@ -1,19 +0,0 @@
-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

@@ -1,67 +0,0 @@
-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