opal 0.11.0.rc1 → 0.11.0

data/spec/opal/core/helpers_spec.rb

@@ -1,14 +0,0 @@
-require 'spec_helper'
-
-describe Opal do
-  context '.instance_variable_name!' do
-    it 'does not use regular expressions on Opal level, so $` stays the same' do
-      'some string' =~ /string/
-      post_match = $`
-
-      Opal.instance_variable_name!(:@ivar_name)
-
-      expect($`).to eq(post_match)
-    end
-  end
-end

data/spec/opal/core/kernel/Array_spec.rb

@@ -1,10 +0,0 @@
-describe "Kernel#Array" do
-  it "returns an Array containing the argument if it responds to neither #to_ary nor #to_a" do
-    obj = mock('obj')
-    Array(obj).should == [obj]
-  end
-
-  it "returns an empty Array when passed nil" do
-    Array(nil).should == []
-  end
-end

data/spec/opal/core/kernel/at_exit_spec.rb

@@ -1,70 +0,0 @@
-module KernelExit
-  extend self
-  attr_accessor :status, :original_proc, :proc, :out
-
-  self.original_proc = `Opal.exit`
-  self.proc = `function(status){ #{KernelExit.status = `status`} }`
-
-  def out_after_exit
-    `Opal.exit = #{proc}`
-    exit
-    out
-  ensure
-    `Opal.exit = #{original_proc}`
-  end
-
-  def reset!
-    self.out = []
-  end
-end
-
-describe "Kernel.at_exit" do
-  before { KernelExit.reset! }
-
-  def print(n)
-    KernelExit.out << n
-  end
-
-  it "runs after all other code" do
-    Kernel.at_exit {print 5}
-    print 6
-
-    KernelExit.out_after_exit.should == [6,5]
-  end
-
-  it "runs in reverse order of registration" do
-    at_exit {print 4}
-    at_exit {print 5}
-    print 6
-    at_exit {print 7}
-
-    KernelExit.out_after_exit.should == [6,7,5,4]
-  end
-
-  it "allows calling exit inside at_exit handler" do
-    at_exit {print 3}
-    at_exit {
-      print 4
-      exit
-      # print 5 # This one is added to out because Opal.exit doesn't actually exit
-    }
-    at_exit {print 6}
-
-    KernelExit.out_after_exit.should == [6,4,3]
-  end
-
-  # INCOMPLETE: the spec implementation is tricky here
-  # it "gives access to the last raised exception" do
-  #   begin
-  #     at_exit do
-  #       print $!.message
-  #     end
-  #     raise 'foo' rescue nil
-  #     p [:err, $!]
-  #   rescue
-  #   end
-  #
-  #   KernelExit.out_after_exit.should == ['foo']
-  # end
-
-end

data/spec/opal/core/kernel/block_given_spec.rb

@@ -1,30 +0,0 @@
-module BlockGivenSpecs
-  def self.is_block_given
-    block_given?
-  end
-
-  def self.calls_block_given_with_block(&x)
-    is_block_given(&x)
-  end
-end
-
-describe "Kernel#block_given?" do
-  it "can be used outside of a method scope" do
-    block_given?
-  end
-  
-  it "can check if a block was given" do
-    BlockGivenSpecs.is_block_given.should == false
-    BlockGivenSpecs.is_block_given {}.should == true
-  end
-  
-  it "works with explicitly passed blocks" do
-    BlockGivenSpecs.calls_block_given_with_block.should == false
-    BlockGivenSpecs.calls_block_given_with_block {}.should == true
-  end
-  
-  it "works with #to_proc'd blocks" do
-    BlockGivenSpecs.is_block_given(&nil).should == false
-    BlockGivenSpecs.is_block_given(&:x).should == true
-  end
-end if false

data/spec/opal/core/kernel/class_spec.rb

@@ -1,6 +0,0 @@
-describe "Kernel#class" do
-  it "returns the class of the receiver" do
-    Object.new.class.should == Object
-    [].class.should == Array
-  end
-end

data/spec/opal/core/kernel/define_singleton_method_spec.rb

@@ -1,21 +0,0 @@
-class DefineMethodByProcScope
-  in_scope = true
-  method_proc = proc { in_scope }
-
-  define_singleton_method(:proc_test, &method_proc)
-end
-
-describe "Kernel#define_singleton_method" do
-  it "defines a new singleton method for objects" do
-    s = Object.new
-    s.define_singleton_method(:test) { "world!" }
-    s.test.should == "world!"
-    lambda {
-      Object.new.test
-    }.should raise_error(NoMethodError)
-  end
-
-  it "maintains the Proc's scope" do
-    DefineMethodByProcScope.proc_test.should == true
-  end
-end

data/spec/opal/core/kernel/equal_value_spec.rb

@@ -1,12 +0,0 @@
-describe "Kernel#==" do
-  it "returns true only if obj and other are the same object" do
-    o1 = Object.new
-    o2 = Object.new
-    (o1 == o1).should == true
-    (o2 == o2).should == true
-    (o1 == o2).should == false
-    (nil == nil).should == true
-    (o1 == nil).should == false
-    (nil == o2).should == false
-  end
-end

data/spec/opal/core/kernel/extend_spec.rb

@@ -1,21 +0,0 @@
-module KernelExtendSpecs
-  module Mod
-    def foo; 3.142; end
-  end
-
-  class A
-    extend Mod
-  end
-end
-
-describe "Kernel#extend" do
-  it "extends the class/module with the module" do
-    KernelExtendSpecs::A.foo.should == 3.142
-  end
-
-  it "extends the object with the module" do
-    obj = Object.new
-    obj.extend KernelExtendSpecs::Mod
-    obj.foo.should == 3.142
-  end
-end

data/spec/opal/core/kernel/format_spec.rb

@@ -1,122 +0,0 @@
-describe "Kernel#format" do
-  it "should prepend '+' or '-' for numbers when flag '+' is specified" do
-    format("%+d", 1).should == "+1"
-    format("%+x", -1).should == "-1"
-  end
-
-  it "should prepend ' ' or '-' for numbers when flag ' ' is specified" do
-    format("% d", 1).should == " 1"
-    format("% x", 1).should == " 1"
-    format("% x", -1).should ==  "-1"
-  end
-
-  it "should align left when flag '-' is specified" do
-    format("%-5d", 123).should == "123  "
-  end
-
-  it "should prepend '0's when flag '0' is specified" do
-    format("%010d", 10).should == "0000000010"
-  end
-
-  it "should output at least specified number of characters when width is specified" do
-    format("%5d", 123).should == "  123"
-    format("%+5d", 11).should == "  +11"
-    format("%+-5d", 11).should == "+11  "
-    format("%+05d", 11).should == "+0011"
-
-    format("%0*x", 5, 10).should == "0000a"
-  end
-
-  describe "with precision" do
-    it "should output specified number of digits for integers" do
-      format("%10.5d", 1).should == "     00001"
-      format("%+10.5x", 1).should == "    +00001"
-    end
-
-    it "should output specified number of significant digits for floats" do
-      format("%10.5f", 1).should == "   1.00000"
-      format("%10.5f", 10).should == "  10.00000"
-
-      (format("%10.5e", 1) =~ /^1\.00000e\+0*0$/).should_not == nil
-      (format("%10.5e", 10) =~ /^1\.00000e\+0*1$/).should_not == nil
-    end
-
-    it "should output at most specified number of characters for strings" do
-      format("%10.2s", "foo").should == "        fo"
-
-      format("%5.5s", "foo").should == "  foo"
-      format("%5.5s", "foobar").should == "fooba"
-
-      format("%.5s", "foobar").should == "fooba"
-      format("%.*s", 5, "foobar").should == "fooba"
-    end
-  end
-
-  it "should format a character with specifier 'c'" do
-    format("%c", 97).should == "a"
-    format("%c", 'a').should == "a"
-  end
-
-  it "should format a string with specifier 's'" do
-    format("%s", "foo").should == "foo"
-  end
-
-  it "should format an object with specifier 'p'" do
-    format("%p", "foo").should == "\"foo\""
-  end
-
-  it "should format an integer with specifier 'd' or 'i'" do
-    format("%d", -1).should == "-1"
-    format("%d", 3.1).should == "3"
-  end
-
-  it "should format an integer with specifier 'u'" do
-    format("%u", -1).should == "-1"
-  end
-
-  it "should format an integer with specifier 'b', 'B', 'o', 'x' or 'X'" do
-    format("%b", 10).should == "1010"
-    format("%B", 10).should == "1010"
-    format("%o", 10).should == "12"
-    format("%x", 10).should == "a"
-    format("%X", 10).should == "A"
-
-    format("%x", -1).should == "..f"
-  end
-
-  it "should format a floating number with specifier 'f', 'e', 'E', 'g' or 'G'" do
-    format("%f", 1.0).should == "1.000000"
-    (format("%e", 1.0) =~ /^1\.000000e\+0*0$/).should_not == nil
-    format("%g", 1.0).should == "1"
-
-    format("%f", 10.1).should == "10.100000"
-    (format("%E", 10.1) =~ /^1\.010000E\+0*1$/).should_not == nil
-    format("%g", 10.1).should == "10.1"
-
-    format("%g", 1000000).should == "1e+06"
-    format("%g", 0.0000001).should == "1e-07"
-  end
-
-  it "should format special floating number special values" do
-    format("%f",  1.0/0).should == "Inf"
-    format("%f", -1.0/0).should == "-Inf"
-    format("%f",  0.0/0).should == "NaN"
-
-    format("%E",  1.0/0).should == "Inf"
-    format("%E", -1.0/0).should == "-Inf"
-    format("%E",  0.0/0).should == "NaN"
-  end
-
-  it "should take specified index of argument if '$' is specified" do
-    format("%d, %x, %o", 1, 2, 3).should == "1, 2, 3"
-    format("%3$d, %2$x, %1$o", 1, 2, 3).should == "3, 2, 1"
-
-    format("%1$d, %1$x, %1$o", 10).should == "10, a, 12"
-
-    format("%1$*2$.*3$f", 1, 5, 2).should == " 1.00"
-  end
-
-  it "can output % by escaping it" do
-    format("%%").should == "%"
-  end
-end

data/spec/opal/core/kernel/freeze_spec.rb

@@ -1,15 +0,0 @@
-# No real support, just mocking
-
-describe "Kernel#freeze" do
-  it 'responds to #freeze and #frozen?' do
-    o = mock('o')
-    o.frozen?.should be_false
-    o.freeze
-    o.frozen?.should be_false
-  end
-
-  it "returns self" do
-    o = Object.new
-    o.freeze.should equal(o)
-  end
-end

data/spec/opal/core/kernel/instance_eval_spec.rb

@@ -1,28 +0,0 @@
-describe "Kernel#instance_eval" do
-  before :each do
-    ScratchPad.clear
-  end
-
-  it "yields the object to the block" do
-    "hola".instance_eval { |o| ScratchPad.record o }
-    ScratchPad.recorded.should == "hola"
-  end
-
-  it "returns the result of the block" do
-    "hola".instance_eval { :result }.should == :result
-  end
-
-  it "binds self to the receiver" do
-    s = "hola"
-    (s == s.instance_eval { self }).should be_true
-  end
-
-  it "executes in the context of the receiver" do
-    "Ruby-fu".instance_eval { size }.should == 7
-  end
-
-  it "has access to receiver's instance variables" do
-    @foo_bar = 42
-    instance_eval { @foo_bar }.should == 42
-  end
-end

data/spec/opal/core/kernel/instance_variable_defined_spec.rb

@@ -1,15 +0,0 @@
-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/core/kernel/instance_variable_get_spec.rb

@@ -1,14 +0,0 @@
-describe "Kernel#instance_variable_get" do
-  before(:each) do
-    @obj = Object.new
-    @obj.instance_variable_set("@test", :test)
-  end
-
-  it "returns nil when the referred instance variable does not exist" do
-    @obj.instance_variable_get(:@does_not_exist).should be_nil
-  end
-
-  it "returns the value of the passed instance variable" do
-    @obj.instance_variable_get(:@test).should == :test
-  end
-end

data/spec/opal/core/kernel/instance_variable_set_spec.rb

@@ -1,10 +0,0 @@
-describe "Kernel#instance_variable_get" do
-  before(:each) do
-    @obj = Object.new
-  end
-
-  it "sets the value of the referenced variable" do
-    @obj.instance_variable_set(:@test, 42)
-    @obj.instance_variable_get(:@test).should == 42
-  end
-end

data/spec/opal/core/kernel/instance_variables_spec.rb

@@ -1,110 +0,0 @@
-describe "Kernel#instance_variables" do
-  context 'for nil' do
-    it 'returns blank array' do
-      expect(nil.instance_variables).to eq([])
-    end
-  end
-
-  context 'for string' do
-    it 'returns blank array' do
-      expect(''.instance_variables).to eq([])
-    end
-  end
-
-  context 'for non-empty string' do
-    it 'returns blank array' do
-      expect('test'.instance_variables).to eq([])
-    end
-  end
-
-  context 'for hash' do
-    it 'returns blank array' do
-      expect({}.instance_variables).to eq([])
-    end
-
-    context 'for a hash with a default value' do
-      it 'returns a blank array' do
-        hash = Hash.new(0)
-        expect(hash.instance_variables).to eq([])
-      end
-    end
-
-    context 'for a hash with a default proc' do
-      it 'returns a blank array' do
-        hash = Hash.new { 0 }
-        expect(hash.instance_variables).to eq([])
-      end
-    end
-  end
-
-  context 'for non-empty hash' do
-    it 'returns blank array' do
-      expect({ 1 => 2 }.instance_variables).to eq([])
-    end
-  end
-
-  context 'for array' do
-    it 'returns blank array' do
-      expect([].instance_variables).to eq([])
-    end
-  end
-
-  context 'for non-empty array' do
-    it 'returns blank array' do
-      expect((1..20).to_a.instance_variables).to eq([])
-    end
-  end
-
-  context 'for object' do
-    it 'returns blank array' do
-      expect(Object.new.instance_variables).to eq([])
-    end
-  end
-
-  context 'cloned object' do
-    it 'returns same vars as source object' do
-      object = Object.new
-      expect(object.clone.instance_variables).to eq(object.instance_variables)
-    end
-  end
-
-  context 'for object with js keyword as instance variables' do
-    reserved_keywords = %w(
-      @constructor
-      @displayName
-      @__proto__
-      @__parent__
-      @__noSuchMethod__
-      @__count__
-      @hasOwnProperty
-      @valueOf
-    )
-
-    reserved_keywords.each do |ivar|
-      context "#{ivar} as instance variable name" do
-        it "returns non-escaped #{ivar} in instance_variables list" do
-          obj = Object.new
-          obj.instance_variable_set(ivar, 'value')
-
-          expect(obj.instance_variables).to eq([ivar])
-        end
-      end
-    end
-  end
-
-  context 'for a class' do
-    it 'returns blank array' do
-      expect(Class.new.instance_variables).to eq([])
-    end
-  end
-
-  context 'for a class with nested constant' do
-    class ClassWithConstantWithoutIvar
-      A = 1
-    end
-
-    it 'returns blank array' do
-      expect(ClassWithConstantWithoutIvar.instance_variables).to eq([])
-    end
-  end
-end