opal 0.10.0 → 0.11.0

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

@@ -1,223 +0,0 @@
-require 'spec_helper'
-
-class SingletonMethodSuperSpec
-  def meth
-    "bar"
-  end
-
-  def passing_block(*args, &block)
-    [args, block_given?]
-  end
-
-  def self.pass_block(&block)
-    block_given?
-  end
-
-  def super_args(*a)
-    block_given?
-  end
-
-  def self.super_args(*a)
-    block_given?
-  end
-
-  def with_splat_args(*a)
-    a
-  end
-
-  class A < SingletonMethodSuperSpec
-    def passing_block(*a)
-      super
-    end
-
-    def self.pass_block
-      super
-    end
-
-    def super_args(*a)
-      super(*a)
-    end
-
-    def self.super_args(*a)
-      super()
-    end
-
-    def with_splat_args
-      super 2, *[3, 4]
-    end
-  end
-
-  module M
-    def self.foo
-      super
-    end
-  end
-end
-
-class MultipleSuperSpec
-  def to_s
-    if true
-      super
-    else
-      super()
-    end
-  end
-end
-
-# FIXME: we cant make a better test case than this??? For some reason, a single test cannot be deduced
-describe "The 'super' keyword" do
-  it "passes the right arguments when a variable rewrites special `arguments` js object" do
-    Struct.new(:a, :b, :c).new(1, 2, 3).b.should == 2
-  end
-
-  it "calls super method on object that defines singleton method calling super" do
-    obj = SingletonMethodSuperSpec.new
-    def obj.meth; "foo " + super; end
-    obj.meth.should == "foo bar"
-  end
-
-  describe "with no arguments or parens" do
-    before do
-      @obj = SingletonMethodSuperSpec::A.new
-      @kls = SingletonMethodSuperSpec::A
-    end
-
-    it "passes the block to super" do
-      @obj.passing_block(1, 2, 3).should == [[1, 2, 3], false]
-      @obj.passing_block(1, 2, 3) { }.should == [[1, 2, 3], true]
-    end
-
-    it "passes the block to super on singleton methods" do
-      @kls.pass_block.should be_false
-      @kls.pass_block { }.should be_true
-    end
-  end
-
-  describe "with arguments or empty parens" do
-    before do
-      @obj = SingletonMethodSuperSpec::A.new
-      @kls = SingletonMethodSuperSpec::A
-    end
-
-    # TODO: This is not correct behavior (MRI returns true)
-    it "does not pass the block to super" do
-      @obj.super_args(1, 2, 3) { }.should be_false
-      @kls.super_args() { }.should be_false
-    end
-  end
-
-  it "handles splat args" do
-    SingletonMethodSuperSpec::A.new.with_splat_args.should == [2, 3, 4]
-  end
-
-  describe "inside a class body" do
-    it "does not break when multiple super statements are in body" do
-      lambda { MultipleSuperSpec.new.to_s }.should_not raise_error
-    end
-  end
-
-  it "works on module singleton methods (see issue #935)" do
-    lambda { SingletonMethodSuperSpec::M.foo }.should raise_error(NoMethodError)
-  end
-end
-
-
-module OpalSuperSpecs
-  class A
-    def foo
-      'a'
-    end
-
-    def self.bar
-      'x'
-    end
-  end
-
-  class B < A
-    def foo
-      super + 'b'
-    end
-
-    def self.bar
-      super + 'y'
-    end
-  end
-
-  class C < B
-    def foo
-      super + 'c'
-    end
-
-    def self.bar
-      super + 'z'
-    end
-  end
-
-  module M1
-    def chain(out)
-      out << 'M1'
-    end
-  end
-
-  module M2
-    def chain(out)
-      out << 'M2'
-      super out
-    end
-  end
-
-  module M3
-    def chain(out)
-      out << 'M3'
-      super out
-    end
-  end
-
-  class C1
-    include M1
-    include M2
-    include M3
-  end
-
-  class C2
-    include M1
-    include M2
-
-    def chain(out)
-      out << 'C2'
-      super out
-    end
-  end
-
-  class C3
-    def chain(out)
-      out << 'C3'
-    end
-  end
-
-  class C4 < C3
-    include M2
-  end
-end
-
-describe "Super chains" do
-  it "searches entire class hierarchys for instance methods" do
-    OpalSuperSpecs::C.new.foo.should == 'abc'
-  end
-
-  it "searches entire class hierarchys for class methods" do
-    OpalSuperSpecs::C.bar.should == 'xyz'
-  end
-
-  it "calls methods for every module included in a class" do
-    OpalSuperSpecs::C1.new.chain([]).should == ['M3', 'M2', 'M1']
-  end
-
-  it "calls method defined in class before modules" do
-    OpalSuperSpecs::C2.new.chain([]).should == ['C2', 'M2', 'M1']
-  end
-
-  it "calls method defined on superclass after modules included by child" do
-    OpalSuperSpecs::C4.new.chain([]).should == ['M2', 'C3']
-  end
-end

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

@@ -1,63 +0,0 @@
-class Boolean
-  def self_as_an_object
-    self
-  end
-end
-
-class JsNil
-  def <(other)
-    %x{
-      return nil;
-    }
-  end
-end
-
-describe "Opal truthyness" do
-  it "should evaluate to true using js `true` as an object" do
-    if true.self_as_an_object
-      called = true
-    end
-
-    called.should be_true
-  end
-
-  it "should evaluate to false using js `false` as an object" do
-    if false.self_as_an_object
-      called = true
-    end
-
-    called.should be_nil
-  end
-  
-  it "should evaluate to false if js `nil` is used with an operator" do
-    is_falsey = JsNil.new < 2 ? false : true
-    
-    is_falsey.should be_true
-  end
-
-  it "should consider false, nil, null, and undefined as not truthy" do
-    called = nil
-    [`false`, `nil`, `null`, `undefined`].each do |v|
-      if v
-        called = true
-      end
-    end
-
-    called.should be_nil
-  end
-
-  it "should true as truthy" do
-    if `true`
-      called = true
-    end
-
-    called.should be_true
-  end
-
-  it "should handle logic operators correctly for false, nil, null, and undefined" do
-    (`false` || `nil` || `null` || `undefined` || 1).should == 1
-    [`false`, `nil`, `null`, `undefined`].each do |v|
-      `#{1 && v} === #{v}`.should == true
-    end
-  end
-end

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

@@ -1,20 +0,0 @@
-require 'spec_helper'
-
-describe "Mass assignment" do
-  it "supports setting attributes on lhs" do
-    object = Class.new { attr_accessor :foo, :bar }.new
-
-    object.foo, object.bar = 100, 200
-
-    object.foo.should == 100
-    object.bar.should == 200
-  end
-
-  it "supports setting []= on lhs" do
-    hash = {}
-    hash[:foo], hash[:bar] = 3.142, 42
-
-    hash[:foo].should == 3.142
-    hash[:bar].should == 42
-  end
-end

data/spec/opal/core/runtime_spec.rb

@@ -1,58 +0,0 @@
-require 'spec_helper'
-
-describe '`Opal.hash`' do
-  it 'converts object literals to hashes' do
-    `Opal.hash({a: 1, b: 2})`.should == {a: 1, b: 2}
-  end
-end
-
-describe 'javascript access using .JS' do
-  it 'should call javascript methods via .JS.method()' do
-    "a1234b5678c".JS.indexOf('c').should == 10
-    "a1234b5678c".JS.replace(/[0-9]/g, '').should == 'abc'
-  end
-
-  it 'should call javascript methods via .JS.method arg' do
-    ("a1234b5678c".JS.indexOf 'c').should == 10
-    ("a1234b5678c".JS.replace /[0-9]/g, '').should == 'abc'
-  end
-
-  it 'should call javascript methods with blocks via .JS.method' do
-    f = `{a:function(f){return f(1) + f(2)}}`
-    f.JS.a{|v| v*2}.should == 6
-    v = f.JS.a do |v| v*2 end
-    v.should == 6
-  end
-
-  it 'should call javascript methods with args and blocks via .JS.method' do
-    f = `{a:function(a, f){return f(a, 1) + f(a, 2)}}`
-    f.JS.a(3){|b, v| b+v*2}.should == 12
-    v = f.JS.a 3 do |b, v| b+v*2 end
-    v.should == 12
-  end
-
-  it 'should support javascript properties via .JS[]' do
-    "a1234b5678c".JS['length'].should == 11
-    `{a:1}`.JS['a'].should == 1
-    `{a:1}`.JS['a'].should == 1
-    [2, 4].JS[0].should == 2
-    [2, 4].JS[1].should == 4
-    [2, 4].JS[:length].should == 2
-  end
-
-  it 'should be chainable' do
-    "a1234b5678c".JS.replace(/[0-9]/g, '').JS.toUpperCase.should == 'ABC'
-    "a1234b5678c".JS.replace(/[0-9]/g, '').JS[:length].should == 3
-    "a1234b5678c".JS[:length].JS.toString.should == "11"
-    `{a:{b:1}}`.JS[:a].JS[:b].JS.toString.should == '1'
-    f = `{a:function(f){return {b: function(f2){return f(f2(1)) + f(f2(2))}}}}`
-    f.JS.a{|v| v*2}.JS.b{|v| v*3}.should == 18
-  end
-
-  it 'should set javascript properties via .JS[arg] = rhs' do
-    a = `{}`
-    a.JS[:foo] = 1
-    a.JS[:foo].should == 1
-    `a["foo"]`.should == 1
-  end
-end

data/spec/opal/core/source_map_spec.rb

@@ -1,49 +0,0 @@
-require 'spec_helper'
-require 'opal-source-maps'
-
-describe Opal::SourceMap do
-  before do
-    pathname = 'foo.rb'
-    compiler = Opal::Compiler.new("def foo\n123\nend", :file => pathname)
-    @source  = compiler.compile
-    @map     = Opal::SourceMap.new(compiler.fragments, pathname)
-  end
-
-  def js_line_for(code)
-    index = @source.split("\n").index {|line| line.include?(code)}
-    # 1 based line numbers
-    index + 1
-  end
-
-  def parsed_map
-    SourceMap::Map.from_json(@map.as_json.to_json)
-  end
-
-  def mappings
-    mappings = []
-    # mappings is not exposed on the ext library
-    parsed_map.each do |mapping|
-      mappings << mapping
-    end
-    mappings
-  end
-
-  it 'does not blow while generating the map' do
-    lambda { @map.as_json }.should_not raise_error
-  end
-
-  it 'parses the map without error' do
-    parsed_map.should_not be_nil
-  end
-
-  it 'identifies line numbers' do
-    match = mappings.find {|map| map.original.line == 2 }
-    # as of Opal 0.10
-    match.generated.line.should == js_line_for('return 123')
-  end
-
-  it 'uses method names' do
-    match = mappings.find {|map| map.original.line == 2 }
-    match.name.should == 'foo'
-  end
-end

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/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,33 +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
-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