opal 0.11.0.rc1 → 0.11.0

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,19 +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 "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,44 +0,0 @@
-class RespondToSpecs
-  def self.bar
-    'done'
-  end
-
-  def undefed_method
-    true
-  end
-
-  undef undefed_method
-
-  def some_method
-    :foo
-  end
-
-  def 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}.$foo.$$stub = true`
-    @a.respond_to?(:foo).should be_false
-  end
-end

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

@@ -1,56 +0,0 @@
-module KernelSpecs
-  class Foo
-    def bar
-      'done'
-    end
-
-    alias :aka :bar
-
-    def baz(*args) args end
-
-    def foo(first, *rest) [first, *rest] end
-
-    def buz(first = true) first end
-
-    def self.bar
-      'done'
-    end
-  end
-end
-
-describe "Kernel#send" do
-  it "invokes the named public method" do
-    KernelSpecs::Foo.new.send(:bar).should == 'done'
-  end
-
-  it "invokes the named alias of a public method" do
-    KernelSpecs::Foo.new.send(:aka).should == 'done'
-  end
-end
-
-describe "Kernel#send" do
-  it "invokes the named method" do
-    KernelSpecs::Foo.new.send(:bar).should == 'done'
-  end
-
-  it "invokes a class method if called on a class" do
-    KernelSpecs::Foo.send(:bar).should == 'done'
-  end
-
-  it "succeeds if passed an arbitrary number of arguments as a splat parameter" do
-    KernelSpecs::Foo.new.send(:baz).should == []
-    KernelSpecs::Foo.new.send(:baz, :quux).should == [:quux]
-    KernelSpecs::Foo.new.send(:baz, :quux, :foo).should == [:quux, :foo]
-  end
-
-  it "succeeds when passing 1 or more arguments as a required and a splat parameter" do
-    KernelSpecs::Foo.new.send(:foo, :quux).should == [:quux]
-    KernelSpecs::Foo.new.send(:foo, :quux, :bar).should == [:quux, :bar]
-    KernelSpecs::Foo.new.send(:foo, :quux, :bar, :baz).should == [:quux, :bar, :baz]
-  end
-
-  it "succeeds when passing 0 arguments to a method with one parameter with a default" do
-    KernelSpecs::Foo.new.send(:buz).should == true
-    KernelSpecs::Foo.new.send(:buz, :arg).should == :arg
-  end
-end

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

@@ -1,5 +0,0 @@
-describe "Kernel#sprintf" do
-  it "returns formatted string as same as Kernel#format" do
-    sprintf("%5d", 123).should == "  123"
-  end
-end

data/spec/opal/core/language/arguments/mlhs_arg_spec.rb

@@ -1,19 +0,0 @@
-# regression test
-describe 'mlhs argument' do
-  context 'when pased value is falsey in JS' do
-    it 'still returns it' do
-      p = ->((a)){ a }
-      p.call(false).should == false
-      p.call("").should == ""
-      p.call(0).should == 0
-    end
-  end
-
-  context 'when passed value == null' do
-    it 'replaces it with nil' do
-      p = ->((a)){ a }
-      p.call([`undefined`]).should == nil
-      p.call([`null`]).should == nil
-    end
-  end
-end

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

@@ -1,55 +0,0 @@
-class AssignClassNewConst
-  TEST_CONST = :bar
-
-  def foo
-    TEST_CONST
-  end
-
-  def self.assign_klass
-    k = Class.new(self) do
-      def foobar
-        # ensure we can still use constants from AssignClassNewConst even though we use AssignClassConstBase
-        TEST_CONST
-      end
-    end
-    AssignClassConstBase.assign_const(k)
-  end
-end
-
-module AssignClassConstBase
-  def self.assign_const(group)
-    self.const_set("MyStuff", group)
-  end
-end
-
-describe "Assigning Class.new to a constant" do
-  klass = Class.new do
-    def bar
-      :bar
-    end
-  end
-  ConstantWithAssignedClass = klass
-  class ConstantWithAssignedClass
-    def foo
-      :foo
-    end
-  end
-
-  it "sets the class' name" do
-    ConstantWithAssignedClass.name.should == 'ConstantWithAssignedClass'
-  end
-
-  it "can be reopened by the constant name" do
-    ConstantWithAssignedClass.new.foo.should == :foo
-    ConstantWithAssignedClass.new.bar.should == :bar
-  end
-
-  it "respects a different base scope" do
-    AssignClassNewConst.assign_klass
-    AssignClassConstBase::MyStuff.to_s.should == "AssignClassConstBase::MyStuff"
-    AssignClassConstBase::MyStuff.name.should == "AssignClassConstBase::MyStuff"
-    obj = AssignClassConstBase::MyStuff.new
-    obj.foo.should == :bar
-    obj.foobar.should == :bar
-  end
-end

data/spec/opal/core/language/constant_lookup_spec.rb

@@ -1,38 +0,0 @@
-ConstantLookupSpec_TopDef = 123
-def self._ConstantLookupSpec_TopDef
-  ConstantLookupSpec_TopDef
-end
-ConstantLookupSpec_TopDefValue = _ConstantLookupSpec_TopDef
-
-module ConstantLookupSpec_Module
-end
-class ConstantLookupSpec_Class
-end
-
-module ConstantLookupSpec_Namespace
-  class NamespacedClass
-    def self.foo
-      ConstantLookupSpec_TopDef
-    end
-  end
-end
-
-
-describe 'constant lookup' do
-  it 'can reach constants from methods defined at top level' do
-    ::ConstantLookupSpec_TopDefValue.should == 123
-    ::ConstantLookupSpec_TopDefValue.should == ::ConstantLookupSpec_TopDef
-    ::ConstantLookupSpec_TopDefValue.should == ConstantLookupSpec_TopDef
-  end
-
-  it 'cannot reach a toplevel constant from a qualified lookup on another toplevel constant' do
-    ->{ConstantLookupSpec_Module::ConstantLookupSpec_Class}.should raise_error(NameError)
-
-    # When the cref is a module then ::Object is added to the search
-    ->{ConstantLookupSpec_Class::ConstantLookupSpec_Module}.should_not raise_error
-  end
-
-  it 'can reach a constant from inside a namespaced class' do
-    ConstantLookupSpec_Namespace::NamespacedClass.foo.should == 123
-  end
-end

data/spec/opal/core/language/equal_spec.rb

@@ -1,8 +0,0 @@
-describe "BasicObject#equal?" do
-  it "compares usign low level identity" do
-    obj = BasicObject.new
-    obj2 = BasicObject.new
-    obj.equal?(obj).should == true
-    obj.equal?(obj2).should == false
-  end
-end

data/spec/opal/core/language/fixtures/array.rb

@@ -1,11 +0,0 @@
-module ArraySpec
-  class Splat
-    def unpack_3args(a, b, c)
-      [a, b, c]
-    end
-
-    def unpack_4args(a, b, c, d)
-      [a, b, c, d]
-    end
-  end
-end