opal 0.10.0 → 0.11.0

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

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

@@ -1,23 +0,0 @@
-describe "Kernel.loop" do
-  it "calls block until it is terminated by a break" do
-    i = 0
-    loop do
-      i += 1
-      break if i == 10
-    end
-
-    i.should == 10
-  end
-
-  it "returns value passed to break" do
-    loop do
-      break 123
-    end.should == 123
-  end
-
-  it "returns nil if no value passed to break" do
-    loop do
-      break
-    end.should == nil
-  end
-end

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

@@ -1,5 +0,0 @@
-describe "Kernel#=~" do
-  it "should return false" do
-    (Object.new =~ 'abc').should be_false
-  end
-end

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

@@ -1,31 +0,0 @@
-module KernelSpecs
-  class Foo
-    def bar
-      'done'
-    end
-
-    def self.baz
-      'class done'
-    end
-  end
-end
-
-describe "Kernel#method" do
-  it "returns a method object for a valid method" do
-    m = KernelSpecs::Foo.new.method(:bar)
-    m.should be_kind_of(Method)
-    m.call.should == 'done'
-  end
-
-  it "returns a method object for a valid singleton method" do
-    m = KernelSpecs::Foo.method(:baz)
-    m.should be_kind_of Method
-    m.call.should == 'class done'
-  end
-
-  it "raises a NameError for an invalid method name" do
-    lambda {
-      KernelSpecs::Foo.new.method(:invalid_and_silly_method_name)
-    }.should raise_error(NameError)
-  end
-end

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

@@ -1,25 +0,0 @@
-module MethodsSpecs
-  class Issue < Object
-    def unique_method_name
-    end
-  end
-
-  # Trigger stub generation
-  Issue.new.unique_method_name
-end
-
-describe "Kernel#methods" do
-  it "lists methods available on an object" do
-    Object.new.methods.include?("puts").should == true
-  end
-
-  it "lists only singleton methods if false is passed" do
-    o = Object.new
-    def o.foo; 123; end
-    o.methods(false).should == ["foo"]
-  end
-
-  it "ignores stub methods" do
-    Object.methods.include?(:unique_method_name).should be_false
-  end
-end

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

@@ -1,7 +0,0 @@
-describe "Kernel#nil?" do
-  it "should return false for all object that are not nil" do
-    Object.new.nil?.should be_false
-    0.nil?.should be_false
-    false.nil?.should be_false
-  end
-end

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

@@ -1,15 +0,0 @@
-describe "Kernel#p" do
-  before { extend OutputSilencer }
-
-  it "returns nil if called with no arguments" do
-    silence_stdout { p.should == nil }
-  end
-
-  it "returns its argument if called with one argument" do
-    silence_stdout { p(123).should == 123 }
-  end
-
-  it "returns all arguments as an Array if called with multiple arguments" do
-    silence_stdout { p(1,2,3).should == [1,2,3] }
-  end
-end

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

@@ -1,11 +0,0 @@
-describe "Kernel#printf" do
-  before { extend OutputSilencer }
-
-  it "returns nil if called with no arguments" do
-    silence_stdout { printf.should == nil }
-  end
-
-  it "returns nil if called with arguments" do
-    silence_stdout { printf("%d", 123).should == nil }
-  end
-end

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

@@ -1,13 +0,0 @@
-describe "Kernel#proc" do
-  it "returns a Proc object" do
-    proc { true }.kind_of?(Proc).should == true
-  end
-
-  it "raises an ArgumentError when no block is given" do
-    lambda { proc }.should raise_error(ArgumentError)
-  end
-  
-  it "is not a lambda" do
-    proc { true }.lambda?.should == false
-  end
-end

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

@@ -1,13 +0,0 @@
-describe "Kernel#raise" do
-  # ruby-specs test most of this, but ruby-specs won't differentiate between nil and undefined
-  it "raises messages without exceptions" do
-    lambda { raise Exception }.should raise_error(Exception)
-    ex = nil
-    begin
-      raise Exception
-    rescue Exception => e
-      ex = e
-    end
-    ex.to_s.should == 'Exception'
-  end
-end

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

@@ -1,23 +0,0 @@
-describe "Kernel.rand" do
-  it "returns a float if no argument is passed" do
-    rand.should be_kind_of(Float)
-  end
-
-  it "returns an integer for an integer argument" do
-    rand(77).should be_kind_of(Integer)
-  end
-
-  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
-    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)
-  end
-end

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

@@ -1,18 +0,0 @@
-describe 'Kernel.require_tree' do
-  it 'loads all the files in a directory' do
-    $ScratchPad = []
-    require_tree '../fixtures/require_tree_files'
-
-    $ScratchPad.sort.should == ['file 1', 'file 2', 'file 3', 'file 4', 'file 5',
-                                'nested 1', 'nested 2', 'other 1']
-  end
-
-  it 'can be used with "."' do
-    $ScratchPad = []
-    require_relative '../fixtures/require_tree_with_dot/index'
-
-    $ScratchPad[0].should == 'indexpre'
-    $ScratchPad[1...-1].sort.should == ['file 1', 'file 2', 'file 3']
-    $ScratchPad[-1].should == 'indexpost'
-  end
-end

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

@@ -1,41 +0,0 @@
-class RespondToSpecs
-  def self.bar
-    'done'
-  end
-
-  def undefed_method
-    true
-  end
-
-  undef undefed_method
-
-  def some_method
-    :foo
-  end
-end
-
-describe "Kernel.respond_to?" do
-  it "indicates if a singleton object responds to a particular message" do
-    RespondToSpecs.respond_to?(:bar).should == true
-    RespondToSpecs.respond_to?(:baz).should == false
-  end
-end
-
-describe "Kernel#respond_to?" do
-  before :each 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
-
-  it "returns false if a method exists, but is marked with a '$$stub' property" do
-    `#{@a}.$some_method.$$stub = true`
-    @a.respond_to?(:some_method).should be_false
-  end
-end