opal-wedge 0.9.0.dev

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

@@ -0,0 +1,23 @@
+class Boolean
+  def self_as_an_object
+    self
+  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
+end

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

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

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

@@ -0,0 +1,15 @@
+require 'spec_helper'
+require 'opal-source-maps'
+
+describe Opal::SourceMap do
+  before do
+    pathname = 'foo.rb'
+    compiler = Opal::Compiler.new("1 + 1", :file => pathname)
+    @source  = compiler.compile
+    @map     = Opal::SourceMap.new(compiler.fragments, pathname)
+  end
+
+  it 'does not blow while generating the map' do
+    lambda { @map.as_json }.should_not raise_error
+  end
+end

data/spec/opal/core/string_spec.rb

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

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

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

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

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

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

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

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

data/spec/opal/stdlib/js_spec.rb

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

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

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

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