opal 0.3.11 → 0.3.15

data/runtime/spec/language/or_spec.rb

@@ -0,0 +1,65 @@
+require File.expand_path('../../spec_helper', __FILE__)
+
+describe "The || operator" do
+  it "evaluates to true if any of its operands are true" do
+    if false || true || nil
+      x = true
+    end
+    x.should == true
+  end
+
+  it "evaluates to false if all of its operands are false" do
+    if false || nil
+      x = true
+    end
+    x.should == nil
+  end
+
+  it "is evaluated before assignment operators" do
+    x = nil || true
+    x.should == true
+  end
+
+  it "has a lower precedence than the && operator" do
+    x = 1 || false && x = 2
+    x.should == 1
+  end
+
+  it "treats empty expressions as nil" do
+    (() || true).should be_true
+    (() || false).should be_false
+    (true || ()).should be_true
+    (false || ()).should be_nil
+    (() || ()).should be_nil
+  end
+end
+
+describe "The or operator" do
+  it "evaluates to true if any of its operands are true" do
+    x = nil
+    if false or true
+      x = true
+    end
+    x.should == true
+  end
+
+  it "is evaluated after variables are assigned" do
+    x = nil or true
+    x.should == nil
+  end
+
+  it "has a lower precedence than the || operator" do
+    x = y= nil
+    x = true || false or y = 1
+    y.should == nil
+  end
+
+  it "treats empty expressions as nil" do
+    (() or true).should be_true
+    (() or false).should be_false
+    (true or ()).should be_true
+    (false or ()).should be_nil
+    (() or ()).should be_nil
+  end
+end
+

data/runtime/spec/language/predefined_spec.rb

@@ -0,0 +1,21 @@
+require File.expand_path('../../spec_helper', __FILE__)
+
+describe "Predefined global $~" do
+  it "is set to contain the MatchData object of the last match if successful" do
+    md = /foo/.match 'foo'
+    $~.should be_kind_of(MatchData)
+    $~.object_id.should == md.object_id
+
+    /bar/ =~ 'bar'
+    $~.should be_kind_of(MatchData)
+    $~.object_id.should_not == md.object_id
+  end
+
+  it "is set to nil if the last match was unsuccessful" do
+    /foo/ =~ 'foo'
+    $~.nil?.should == false
+
+    /foo/ =~ 'bar'
+    $~.nil?.should == true
+  end
+end

data/runtime/spec/language/regexp/interpolation_spec.rb

@@ -0,0 +1,9 @@
+require File.expand_path('../../../spec_helper', __FILE__)
+
+describe "Regexps with interpolation" do
+
+  it "allows interpolation of strings" do
+    str = "foo|bar"
+    /#{str}/.should == /foo|bar/
+  end
+end

data/runtime/spec/language/regexp_spec.rb

@@ -0,0 +1,7 @@
+require File.expand_path('../../spec_helper', __FILE__)
+
+describe "Literal Regexps" do
+  it "yields a Regexp" do
+    /Hello/.should be_kind_of(Regexp)
+  end
+end

data/runtime/spec/language/send_spec.rb

@@ -0,0 +1,105 @@
+require File.expand_path('../../spec_helper', __FILE__)
+require File.expand_path('../fixtures/send', __FILE__)
+
+specs = LangSendSpecs
+
+describe "Invoking a method" do
+  describe "with zero arguments" do
+    it "requires no arguments passed" do
+      specs.fooM0.should == 100
+    end
+
+    it "raises ArgumentError if the method has a positive arity" do
+      lambda {
+        specs.fooM1
+      }.should raise_error(ArgumentError)
+    end
+  end
+
+  describe "with only manditory arguments" do
+    it "requires exactly thr same number of passed values" do
+      specs.fooM1(1).should == [1]
+      specs.fooM2(1,2).should == [1,2]
+      specs.fooM3(1,2,3).should == [1,2,3]
+      specs.fooM4(1,2,3,4).should == [1,2,3,4]
+      specs.fooM5(1,2,3,4,5).should == [1,2,3,4,5]
+    end
+  end
+
+  describe "with optional arguments" do
+    it "uses the optional argument if none is is passed" do
+      specs.fooM0O1.should == [1]
+    end
+
+    it "uses the passed argument if available" do
+      specs.fooM0O1(2).should == [2]
+    end
+  end
+
+  describe "with manditory and optional arguments" do
+    it "uses the passed values in left to right order" do
+      specs.fooM1O1(2).should == [2, 1]
+    end
+  end
+
+  describe "with a rest argument" do
+    it "is an empty array if there are no additional arguments" do
+      specs.fooM0R().should == []
+      specs.fooM1R(1).should == [1, []]
+    end
+
+    it "gathers unused arguments" do
+      specs.fooM0R(1).should == [1]
+      specs.fooM1R(1,2).should == [1, [2]]
+    end
+  end
+
+  it "with a block makes it available to yield" do
+    specs.oneb(10) { 200 }.should == [10,200]
+  end
+
+  it "wwith a block converts the block to a Proc" do
+    prc = specs.makeproc { "hello" }
+    prc.should be_kind_of(Proc)
+    prc.call.should == "hello"
+  end
+
+  it "with an object as a block used 'to_proc' for coercion" do
+    o = LangSendSpecs::ToProc.new(:from_to_proc)
+
+    specs.makeproc(&o).call.should == :from_to_proc
+
+    specs.yield_now(&o).should == :from_to_proc
+  end
+
+  it "with same names as existing variables is ok" do
+    foobar = 100
+
+    def foobar; 200; end
+
+    foobar.should == 100
+    foobar().should == 200
+  end
+
+  it "with splat operator makes the object the direct arguments" do
+    a = [1,2,3]
+    specs.fooM3(*a).should == [1,2,3]
+  end
+
+  it "without parantheses works" do
+    (specs.fooM3 1,2,3).should == [1,2,3]
+  end
+
+  it "passes literal hashes without curly braces as the last parameter" do
+    specs.fooM3('abc', 456, 'rbx' => 'cool', 'specs' => 'fail sometimes', 'oh' => 'weh').should == ['abc', 456, {'rbx' => 'cool', 'specs' => 'fail sometimes', 'oh' => 'weh'}]
+  end
+
+  it "passes a literal hash without curly braces or parens" do
+    (specs.fooM3 'abc', 456, 'rbx' => 'cool', 'specs' => 'fail sometimes', 'oh' => 'weh').should == ['abc', 456, {'rbx' => 'cool', 'specs' => 'fail sometimes', 'oh' => 'weh'}]
+  end
+
+  it "allows to literal hashes without curly braces as the only parameter" do
+    specs.fooM1(:rbx => :cool, :specs => :fail_sometimes).should == [{ :rbx => :cool, :specs => :fail_sometimes }]
+    (specs.fooM1 :rbx => :cool, :specs => :fail_sometimes).should == [{ :rbx => :cool, :specs => :fail_sometimes }]
+  end
+end

data/runtime/spec/language/string_spec.rb

@@ -0,0 +1,4 @@
+require File.expand_path('../../spec_helper', __FILE__)
+
+describe "Ruby character strings" do
+end

data/runtime/spec/language/super_spec.rb

@@ -0,0 +1,18 @@
+require File.expand_path('../../spec_helper', __FILE__)
+require File.expand_path('../fixtures/super', __FILE__)
+
+describe "The super keyword" do
+  it "calls the method on the calling class" do
+    Super::S1::A.new.foo([]).should == ["A#foo", "A#bar"]
+    Super::S1::A.new.bar([]).should == ["A#bar"]
+    Super::S1::B.new.foo([]).should == ["B#foo", "A#foo", "B#bar", "A#bar"]
+    Super::S1::B.new.bar([]).should == ["B#bar", "A#bar"]
+  end
+
+  it "searches the full inheritence chain" do
+    Super::S2::B.new.foo([]).should == ["B#foo", "A#baz"]
+    Super::S2::B.new.baz([]).should == ["A#baz"]
+    Super::S2::C.new.foo([]).should == ["B#foo", "C#baz", "A#baz"]
+    Super::S2::C.new.baz([]).should == ["C#baz", "A#baz"]
+  end
+end

data/runtime/spec/language/symbol_spec.rb

@@ -0,0 +1,41 @@
+require File.expand_path('../../spec_helper', __FILE__)
+
+describe "A Symbol literal" do
+  it "is a ':' followed by any number of valid characters" do
+    a = :foo
+    a.should be_kind_of(Symbol)
+    # FIXME: this doesnt work as Symbols are Strings
+    #a.inspect.should == ':foo'
+  end
+
+  it "is a ':' followed by any valid variable, method, or constant name" do
+    # Add more of these?
+    [ :Foo,
+      :foo,
+      :@foo,
+      :@@foo,
+      :$foo,
+      :_,
+      :~,
+      :-,
+      :FOO,
+      :_Foo,
+      :&,
+      :_9
+    ].each { |s| s.should be_kind_of(Symbol) }
+  end
+
+  it "is a ':' followed by a single- or double-quoted string that may contain otherwise invalid characters" do
+    [ [:'foo bar',      ':"foo bar"'],
+      [:'++',           ':"++"'],
+      [:'9',            ':"9"'],
+      [:"foo #{1 + 1}", ':"foo 2"']
+    ].each {
+      # FIXME: Symbols are Strings, so #inspect wont work
+    }
+  end
+
+  it "may contain '::' in the string" do
+    :'Some::Class'.should be_kind_of(Symbol)
+  end
+end

data/runtime/spec/language/undef_spec.rb

@@ -0,0 +1,16 @@
+require File.expand_path('../../spec_helper', __FILE__)
+
+class UndefSpecClass
+  def meth(other);other;end
+end
+
+describe "The undef keyword" do
+  it "undefines 'meth='" do
+    obj = ::UndefSpecClass.new
+    (obj.meth 5).should == 5
+    class ::UndefSpecClass
+      undef meth
+    end
+    lambda { obj.meth 5 }.should raise_error(NoMethodError)
+  end
+end

data/runtime/spec/language/unless_spec.rb

@@ -0,0 +1,44 @@
+require File.expand_path('../../spec_helper', __FILE__)
+
+describe "The unless expression" do
+  it "evaluates the unless body when the expression is false" do
+    unless false
+      a = true
+    else
+      a = false
+    end
+
+    a.should == true
+  end
+
+  it "returns the last statement in the body" do
+    unless false
+      'foo'
+      'bar'
+      'baz'
+    end.should == 'baz'
+  end
+
+  it "evaluates the else body when the expression is true" do
+    unless true
+      'foo'
+    else
+      'bar'
+    end.should == 'bar'
+  end
+
+  it "takes and optional then after the expression" do
+    unless false then
+      'baz'
+    end.should == 'baz'
+  end
+
+  it "does not return a value when the expression is true" do
+    unless true; end.should == nil
+  end
+
+  it "allows expression and body to be on one line (using 'then')" do
+    unless false then 'foo'; else 'bar'; end.should == 'foo'
+  end
+end
+

data/runtime/spec/language/until_spec.rb

@@ -0,0 +1,137 @@
+require File.expand_path('../../spec_helper', __FILE__)
+
+describe "The until expression" do
+  it "runs while the expression is false" do
+    i = 0
+    until i > 9
+      i += 1
+    end
+
+    i.should == 10
+  end
+
+  it "optionally takes a 'do' after the expression" do
+    i = 0
+    until i > 9 do
+      i += 1
+    end
+
+    i.should == 10
+  end
+
+  it "allows body begin on the same line if do is used" do
+    i = 0
+    until i > 9 do i += 1
+    end
+
+    i.should == 10
+  end
+
+  it "executes code in containing variable scope" do
+    i = 0
+    until i == 1
+      a = 123
+      i = 1
+    end
+
+    a.should == 123
+  end
+
+  it "executes code in containing variable scope with 'do'" do
+    i = 0
+    until i == 1 do
+      a = 123
+      i = 1
+    end
+
+    a.should == 123
+  end
+
+  it "returns nil if ended when condition became true" do
+    i = 0
+    until i > 9
+      i += 1
+    end.should == nil
+  end
+
+  it "evaluates the body if expression is empty" do
+    a = []
+    until ()
+      a << :body_evaluated
+      break
+    end
+    a.should == [:body_evaluated]
+  end
+
+  it "stops running body if interrupted by break" do
+    i = 0
+    until i > 9
+      i += 1
+      break if i > 5
+    end
+    i.should == 6
+  end
+
+  it "returns value passed to break if interrupted by break" do
+    until false
+      break 123
+    end.should == 123
+  end
+
+  it "returns nil if interrupted by break with no arguments" do
+    until false
+      break
+    end.should == nil
+  end
+
+  it "skips to end of body with next" do
+    a = []
+    i = 0
+    until (i+=1)>=5
+      next if i==3
+      a << i
+    end
+    a.should == [1, 2, 4]
+  end
+end
+
+describe "The until modifier" do
+  it "runs preceding statement while the condition is false" do
+    i = 0
+    i += 1 until i > 9
+    i.should == 10
+  end
+
+  it "evaluates condition before statement execution" do
+    a = []
+    i = 0
+    a << i until (i+=1) >= 3
+    a.should == [1,2]
+  end
+
+  it "does not run the preceding statement if the condition is true" do
+    i = 0
+    i += 1 until true
+    i.should == 0
+  end
+
+  it "returns nil if ended when condition became true" do
+    i = 0
+    (i += 1 until i>9).should == nil
+  end
+
+  it "returns value passed to break if interrupted by break" do
+    (break 123 until false).should == 123
+  end
+
+  it "returns nil if interrupted by break with no arguments" do
+    (break until false).should == nil
+  end
+
+  it "skips to end of body with next" do
+    i = 0
+    j = 0
+    ((i+=1) == 3 ? next : j+=i) until i > 10
+    j.should == 63
+  end
+end