opal 0.4.3 → 0.4.4

data/spec/opal/class/constants_spec.rb

@@ -0,0 +1,7 @@
+require 'spec_helper'
+
+describe "Class#constants" do
+  it "does not break on Object" do
+    Object.constants.should be_kind_of(Array)
+  end
+end

data/spec/opal/erb/erb_spec.rb

@@ -2,15 +2,17 @@ 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/erb/simple']
     @quoted = Template['opal/erb/quoted']
+    @inline_block = Template['opal/erb/inline_block']
   end
 
   it "should be defined by their filename on Template namespace" do
-    @simple.should be_kind_of(ERB)
+    @simple.should be_kind_of(Template)
   end
 
   it "calling the block with a context should render the block" do
@@ -22,4 +24,8 @@ describe "ERB files" 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/erb/inline_block.opalerb

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

data/spec/opal/hash/allocate_spec.rb

@@ -0,0 +1,16 @@
+require 'spec_helper'
+
+describe "Hash.allocate" do
+  before { @subclass = Class.new(Hash) }
+
+  it "returns an instance of Hash or subclass" do
+    Hash.allocate.should be_kind_of Hash
+    @subclass.allocate.should be_kind_of @subclass
+  end
+
+  it "should return a Hash ready to be used" do
+    h = @subclass.allocate
+    h[:foo] = 100
+    h[:foo].should == 100
+  end
+end

data/spec/opal/hash/new_spec.rb

@@ -0,0 +1,10 @@
+require 'spec_helper'
+
+describe "Hash.new" do
+  before { @subclass = Class.new(Hash) }
+
+  it "returns a hash with the right class" do
+    Hash.new.class.should == Hash
+    @subclass.new.class.should == @subclass
+  end
+end

data/spec/opal/hash/to_s_spec.rb

@@ -0,0 +1,9 @@
+require 'spec_helper'
+
+describe "Hash#to_s" do
+  it "handles recursive arrays without breaking" do
+    h = {}
+    h['foo'] = h
+    h.to_s.should == '{"foo"=>{...}}'
+  end
+end

data/spec/opal/kernel/instance_variable_defined_spec.rb

@@ -0,0 +1,15 @@
+require 'spec_helper'
+
+describe "Kernel#instance_variable_defined?" do
+  before do
+    @foo = :bar
+  end
+
+  it "returns true if ivar is defined" do
+    instance_variable_defined?(:@foo).should be_true
+  end
+
+  it "returns false if ivar is not defined" do
+    instance_variable_defined?(:@this_does_not_exist).should be_false
+  end
+end

data/spec/opal/kernel/rand_spec.rb

@@ -1,21 +1,21 @@
 describe "Kernel.rand" do
-  pending "returns a float if no argument is passed" do
+  it "returns a float if no argument is passed" do
     rand.should be_kind_of(Float)
   end
 
-  pending "returns an integer for an integer argument" do
+  it "returns an integer for an integer argument" do
     rand(77).should be_kind_of(Integer)
   end
 
-  it "return member from range" do 
+  it "return member from range" do
     r = (1..10)
     r.to_a.include?(rand(r)).should == true
   end
 
-  it "should convert negative number and convert to integer" do 
+  it "should convert negative number and convert to integer" do
     rand(-0.1).should == 0
   end
-  
+
   it "returns a numeric in opal" do
     rand.should be_kind_of(Numeric)
     rand(77).should be_kind_of(Numeric)

data/spec/opal/kernel/respond_to_spec.rb

@@ -8,6 +8,10 @@ class RespondToSpecs
   end
 
   undef undefed_method
+
+  def some_method
+    :foo
+  end
 end
 
 describe "Kernel.respond_to?" do
@@ -22,7 +26,16 @@ describe "Kernel#respond_to?" do
     @a = RespondToSpecs.new
   end
 
+  it "returns true if a method exists" do
+    @a.respond_to?(:some_method).should be_true
+  end
+
   it "indicates if an object responds to a message" do
     @a.respond_to?(:undefed_method).should be_false
   end
-end
+
+  it "returns false if a method exists, but is marked with a 'rb_stub' property" do
+    `#{@a}.$some_method.rb_stub = true`
+    @a.respond_to?(:some_method).should be_false
+  end
+end

data/spec/opal/language/block_spec.rb

@@ -0,0 +1,13 @@
+require 'spec_helper'
+
+describe "Blocks" do
+  it "accept default arguments" do
+    proc { |a, b = 100| [a, b] }.call(:foo, :bar).should == [:foo, :bar]
+    proc { |a, b = 100| [a, b] }.call(:foo).should == [:foo, 100]
+  end
+
+  it "the block variable can be optionally overwritten without destroying original block reference" do
+    klass = Class.new { def foo(&block); block = 100 if false; block; end }
+    klass.new.foo {}.should be_kind_of(Proc)
+  end
+end

data/spec/opal/language/rescue_spec.rb

@@ -0,0 +1,27 @@
+require 'spec_helper'
+
+class RescueReturningSpec
+  def single
+    begin
+      raise "ERROR"
+    rescue
+      :foo
+    end
+  end
+
+  def multiple
+    begin
+      raise "ERROR"
+    rescue
+      to_s
+      :bar
+    end
+  end
+end
+
+describe "The rescue keyword" do
+  it "returns last value of expression evaluated" do
+    RescueReturningSpec.new.single.should == :foo
+    RescueReturningSpec.new.multiple.should == :bar
+  end
+end

data/spec/opal/language/return_spec.rb

@@ -0,0 +1,38 @@
+require 'spec_helper'
+
+class OpalReturnSpec
+  def returning_expression
+    (false || return)
+  end
+
+  def returning_block
+    @values = []
+
+    [1, 2, 3, 4, 5].each do |n|
+      return if n == 3
+      @values << n
+    end
+  end
+
+  attr_reader :values
+
+  def returning_block_value
+    [1, 2, 3, 4, 5].each { return :foo }
+  end
+end
+
+describe "The return statement" do
+  it "can be used as an expression" do
+    OpalReturnSpec.new.returning_expression.should be_nil
+  end
+
+  it "can return from a method when inside a block" do
+    spec = OpalReturnSpec.new
+    spec.returning_block
+    spec.values.size.should == 2
+  end
+
+  it "returns the return value from a method returning by block" do
+    OpalReturnSpec.new.returning_block_value.should == :foo
+  end
+end

data/spec/opal/language/singleton_class_spec.rb

@@ -0,0 +1,13 @@
+require 'spec_helper'
+
+class SingletonClassConstantsSpec
+  class << self
+    $singleton_class_constant_spec = String
+  end
+end
+
+describe "Singleton Classes" do
+  it "looks up constants in body" do
+    $singleton_class_constant_spec.should == String
+  end
+end

data/spec/opal/language/super_spec.rb

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

data/spec/opal/language/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/module/attr_accessor_spec.rb

@@ -0,0 +1,8 @@
+require 'spec_helper'
+
+describe "Module#attr_accessor" do
+  it "can be passed a splat of arguments" do
+    eval "class OpalAttrAccessorSpec; attr_accessor *%w{foo bar baz}; end"
+    OpalAttrAccessorSpec.new.foo.should be_nil
+  end
+end

data/spec/opal/module/constants_spec.rb

@@ -34,7 +34,7 @@ describe "Module#constants" do
     result.size.should == 1
     result.should include("FOO")
   end
-  
+
   it "should only return constants defined directly on class" do
     result = ConstantsSpecsClass.constants
     result.size.should == 3
@@ -44,6 +44,6 @@ describe "Module#constants" do
   it "should include constants inherited from superclass" do
     result = SubConstantsSpecsClass.constants
     result.size.should == 4
-    result.should include("ClASS_CONST4", "CLASS_CONST1", "CLASS_CONST2", "CLASS_CONST3")
+    result.should include("CLASS_CONST4", "CLASS_CONST1", "CLASS_CONST2", "CLASS_CONST3")
   end
 end

data/spec/opal/native/alias_native_spec.rb

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

data/spec/opal/native/each_spec.rb

@@ -0,0 +1,14 @@
+describe "Native#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 "returns an enumerator when no block is given" do
+    enum = Native(`{ a: 2, b: 3 }`).each
+
+    enum.should be_kind_of Enumerator
+    enum.to_a.should == [[:a, 2], [:b, 3]]
+  end
+end

data/spec/opal/native/element_reference_spec.rb

@@ -0,0 +1,14 @@
+describe "Native#[]" 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