opal 0.3.41 → 0.3.42

data/spec/language/not_spec.rb

@@ -0,0 +1,55 @@
+require File.expand_path('../../spec_helper', __FILE__)
+
+describe "The not keyword" do
+  it "negates a `true' value" do
+    (not true).should be_false
+    (not 'true').should be_false
+  end
+
+  it "negates a `false' value" do
+    (not false).should be_true
+    (not nil).should be_true
+  end
+
+  it "accepts an argument" do
+    lambda do
+      not(true)
+    end.should_not raise_error(SyntaxError)
+  end
+
+  it "returns false if the argument is true" do
+    (not(true)).should be_false
+  end
+
+  it "returns true if the argument is false" do
+    (not(false)).should be_true
+  end
+
+  it "returns true if the argument is nil" do
+    (not(nil)).should be_true
+  end
+end
+
+# language_version __FILE__, "not"
+
+describe "The `!' keyword" do
+  it "negates a `true' value" do
+    (!true).should be_false
+    (!'true').should be_false
+  end
+
+  it "negates a `false' value" do
+    (!false).should be_true
+    (!nil).should be_true
+  end
+
+  it "turns a truthful object into `true'" do
+    (!!true).should be_true
+    (!!'true').should be_true
+  end
+
+  it "turns a not truthful object into `false'" do
+    (!!false).should be_false
+    (!!nil).should be_false
+  end
+end

data/spec/language/numbers_spec.rb

@@ -0,0 +1,56 @@
+require File.expand_path('../../spec_helper', __FILE__)
+
+describe "Ruby numbers in various ways" do
+
+  it "the standard way" do
+    435.should == 435
+  end
+
+  it "with underscore separations" do
+    4_35.should == 435
+  end
+
+  it "with some decimals" do
+    4.35.should == 4.35
+  end
+
+  it "with decimals but no integer part should be a SyntaxError" do
+    lambda { eval(".75")  }.should raise_error(SyntaxError)
+    lambda { eval("-.75") }.should raise_error(SyntaxError)
+  end
+
+  # TODO : find a better description
+  it "using the e expression" do
+    1.2e-3.should == 0.0012
+  end
+
+  pending "the hexdecimal notation" do
+    0xffff.should == 65535
+  end
+
+  pending "the binary notation" do
+    # 0b01011.should == 11
+  end
+
+  pending "octal representation" do
+    0377.should == 255
+  end
+
+  ruby_version_is '' ... '1.9' do
+    it "character to numeric shortcut" do
+      ?z.should == 122
+    end
+
+    it "character with control character to numeric shortcut" do
+      # Control-Z
+      #?\C-z.should == 26
+
+      # Meta-Z
+      #?\M-z.should == 250
+
+      # Meta-Control-Z
+      #?\M-\C-z.should == 154
+    end
+  end
+
+end

data/spec/language/or_spec.rb

@@ -1,3 +1,5 @@
+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
@@ -6,7 +8,7 @@ describe "The || operator" do
     x.should == true
   end
 
-  it "evaluates to false if all of its operands are false" do
+  it "evaluated to false if all of its operands are false" do
     if false || nil
       x = true
     end
@@ -30,6 +32,19 @@ describe "The || operator" do
     (false || ()).should be_nil
     (() || ()).should be_nil
   end
+
+  it "has a higher precedence than 'break' in 'break true || false'" do
+    # see also 'break true or false' below
+    lambda { break false || true }.call.should be_true
+  end
+
+  it "has a higher precedence than 'next' in 'next true || false'" do
+    lambda { next false || true }.call.should be_true
+  end
+
+  it "has a higher precedence than 'return' in 'return true || false'" do
+    lambda { return false || true }.call.should be_true
+  end
 end
 
 describe "The or operator" do
@@ -47,7 +62,7 @@ describe "The or operator" do
   end
 
   it "has a lower precedence than the || operator" do
-    x = y= nil
+    x,y = nil
     x = true || false or y = 1
     y.should == nil
   end
@@ -59,4 +74,17 @@ describe "The or operator" do
     (false or ()).should be_nil
     (() or ()).should be_nil
   end
-end
+
+  it "has a lower precedence than 'break' in 'break true or false'" do
+    # see also 'break true || false' above
+    lambda { eval "break true or false" }.should raise_error(SyntaxError, /void value expression/)
+  end
+
+  pending "has a lower precedence than 'next' in 'next true or false'" do
+    lambda { eval "next true or false" }.should raise_error(SyntaxError, /void value expression/)
+  end
+
+  it "has a lower precedence than 'return' in 'return true or false'" do
+    lambda { eval "return true or false" }.should raise_error(SyntaxError, /void value expression/)
+  end
+end

data/spec/language/order_spec.rb

@@ -0,0 +1,79 @@
+require File.expand_path('../../spec_helper', __FILE__)
+
+describe "A method call" do
+  before :each do
+    @obj = Object.new
+    def @obj.foo0(&a)
+      [a ? a.call : nil]
+    end
+    def @obj.foo1(a, &b)
+      [a, b ? b.call : nil]
+    end
+    def @obj.foo2(a, b, &c)
+      [a, b, c ? c.call : nil]
+    end
+    def @obj.foo3(a, b, c, &d)
+      [a, b, c, d ? d.call : nil]
+    end
+    def @obj.foo4(a, b, c, d, &e)
+      [a, b, c, d, e ? e.call : nil]
+    end
+  end
+
+  it "evaluates the receiver first" do
+    (obj = @obj).foo1(obj = nil).should == [nil, nil]
+    (obj = @obj).foo2(obj = nil, obj = nil).should == [nil, nil, nil]
+    (obj = @obj).foo3(obj = nil, obj = nil, obj = nil).should == [nil, nil, nil, nil]
+    (obj = @obj).foo4(obj = nil, obj = nil, obj = nil, obj = nil).should == [nil, nil, nil, nil, nil]
+  end
+
+  pending "evaluates arguments after receiver" do
+    a = 0
+    # (a += 1; @obj).foo1(a).should == [1, nil]
+    # (a += 1; @obj).foo2(a, a).should == [2, 2, nil]
+    # (a += 1; @obj).foo3(a, a, a).should == [3, 3, 3, nil]
+    # (a += 1; @obj).foo4(a, a, a, a).should == [4, 4, 4, 4, nil]
+    a.should == 4
+  end
+
+  it "evaluates arguments left-to-right" do
+    a = 0
+    @obj.foo1(a += 1).should == [1, nil]
+    @obj.foo2(a += 1, a += 1).should == [2, 3, nil]
+    @obj.foo3(a += 1, a += 1, a += 1).should == [4, 5, 6, nil]
+    @obj.foo4(a += 1, a += 1, a += 1, a += 1).should == [7, 8, 9, 10, nil]
+    a.should == 10
+  end
+
+  pending do
+  ruby_bug "redmine #1034", "1.8" do
+    pending "evaluates block pass after arguments" do
+      a = 0
+      p = proc {true}
+      # @obj.foo1(a += 1, &(a += 1; p)).should == [1, true]
+      # @obj.foo2(a += 1, a += 1, &(a += 1; p)).should == [3, 4, true]
+      # @obj.foo3(a += 1, a += 1, a += 1, &(a += 1; p)).should == [6, 7, 8, true]
+      # @obj.foo4(a += 1, a += 1, a += 1, a += 1, &(a += 1; p)).should == [10, 11, 12, 13, true]
+      a.should == 14
+    end
+
+    pending "evaluates block pass after receiver" do
+      p1 = proc {true}
+      p2 = proc {false}
+      p1.should_not == p2
+
+      p = p1
+      # (p = p2; @obj).foo0(&p).should == [false]
+      p = p1
+      # (p = p2; @obj).foo1(1, &p).should == [1, false]
+      p = p1
+      # (p = p2; @obj).foo2(1, 1, &p).should == [1, 1, false]
+      p = p1
+      # (p = p2; @obj).foo3(1, 1, 1, &p).should == [1, 1, 1, false]
+      p = p1
+      # (p = p2; @obj).foo4(1, 1, 1, 1, &p).should == [1, 1, 1, 1, false]
+      p = p1
+    end
+  end
+  end
+end

data/spec/language/precedence_spec.rb

@@ -0,0 +1,483 @@
+require File.expand_path('../../spec_helper', __FILE__)
+
+# Specifying the behavior of operators in combination could
+# lead to combinatorial explosion. A better way seems to be
+# to use a technique from formal proofs that involve a set of
+# equivalent statements. Suppose you have statements A, B, C.
+# If they are claimed to be equivalent, this can be shown by
+# proving that A implies B, B implies C, and C implies A.
+# (Actually any closed circuit of implications.)
+#
+# Here, we can use a similar technique where we show starting
+# at the top that each level of operator has precedence over
+# the level below (as well as showing associativity within
+# the precedence level).
+
+
+# Excerpted from 'Programming Ruby: The Pragmatic Programmer's Guide'
+# Second Edition by Dave Thomas, Chad Fowler, and Andy Hunt, page 324
+
+# Table 22.4. Ruby operators (high to low precedence)
+# Method   Operator                  Description
+# -----------------------------------------------------------------------
+#          :: .
+#  x*      [ ] [ ]=                  Element reference, element set
+#  x       **                        Exponentiation
+#  x       ! ~ + -                   Not, complement, unary plus and minus
+#                                    (method names for the last two are +@ and -@)
+#  x       * / %                     Multiply, divide, and modulo
+#  x       + -                       Plus and minus
+#  x       >> <<                     Right and left shift
+#  x       &                         “And” (bitwise for integers)
+#  x       ^ |                       Exclusive “or” and regular “or” (bitwise for integers)
+#  x       <= < > >=                 Comparison operators
+#  x       <=> == === != =~ !~       Equality and pattern match operators (!=
+#                                    and !~ may not be defined as methods)
+#          &&                        Logical “and”
+#          ||                        Logical “or”
+#          .. ...                    Range (inclusive and exclusive)
+#          ? :                       Ternary if-then-else
+#          = %= /= -= += |= &=       Assignment
+#          >>= <<= *= &&= ||= **=
+#          defined?                  Check if symbol defined
+#          not                       Logical negation
+#          or and                    Logical composition
+#          if unless while until     Expression modifiers
+#          begin/end                 Block expression
+# -----------------------------------------------------------------------
+
+# * Operators marked with 'x' in the Method column are implemented as methods
+# and can be overridden (except != and !~ as noted). (But see the specs
+# below for implementations that define != and !~ as methods.)
+
+# ** These are not included in the excerpted table but are shown here for
+# completeness.
+
+
+# -----------------------------------------------------------------------
+# It seems that this table is not correct as of MRI 1.8.6
+# The correct table derived from MRI's parse.y is as follows:
+#
+# Operator              Assoc    Description
+#---------------------------------------------------------------
+# ! ~ +                   >      Not, complement, unary plus
+# **                      >      Exponentiation
+# -                       >      Unary minus
+# * / %                   <      Multiply, divide, and modulo
+# + -                     <      Plus and minus
+# >> <<                   <      Right and left shift
+# &                       <      “And” (bitwise for integers)
+# ^ |                     <      Exclusive “or” and regular “or” (bitwise for integers)
+# <= < > >=               <      Comparison operators
+# <=> == === != =~ !~     no     Equality and pattern match operators (!=
+#                                and !~ may not be defined as methods)
+# &&                      <      Logical “and”
+# ||                      <      Logical “or”
+# .. ...                  no     Range (inclusive and exclusive)
+# ? :                     >      Ternary if-then-else
+# rescue                  <      Rescue modifier
+# = %= /= -= += |= &=     >      Assignment
+# >>= <<= *= &&= ||= **=
+# defined?                no     Check if symbol defined
+# not                     >      Logical negation
+# or and                  <      Logical composition
+# if unless while until   no     Expression modifiers
+# -----------------------------------------------------------------------
+#
+# [] and []= seem to fall out of here, as well as begin/end
+#
+
+# TODO: Resolve these two tables with actual specs. As the comment at the
+# top suggests, these specs need to be reorganized into a single describe
+# block for each operator. The describe block should include an example
+# for associativity (if relevant), an example for any short circuit behavior
+# (e.g. &&, ||, etc.) and an example block for each operator over which the
+# instant operator has immediately higher precedence.
+
+describe "Operators" do
+  it "! ~ + is right-associative" do
+    (!!true).should == true
+    (~~0).should == 0
+    (++2).should == 2
+  end
+
+  ruby_version_is "" ... "1.9" do
+    it "! ~ + have a higher precedence than **" do
+      class FalseClass; def **(a); 1000; end; end
+      (!0**2).should == 1000
+      class FalseClass; undef_method :**; end
+
+      class UnaryPlusTest; def +@; 50; end; end
+      a = UnaryPlusTest.new
+      (+a**2).should == 2500
+
+      (~0**2).should == 1
+    end
+  end
+
+  it "** is right-associative" do
+    (2**2**3).should == 256
+  end
+
+  it "** has higher precedence than unary minus" do
+    (-2**2).should == -4
+  end
+
+  it "unary minus is right-associative" do
+    (--2).should == 2
+  end
+
+  pending "unary minus has higher precedence than * / %" do
+    class UnaryMinusTest; def -@; 50; end; end
+    b = UnaryMinusTest.new
+
+    (-b * 5).should == 250
+    (-b / 5).should == 10
+    (-b % 7).should == 1
+  end
+
+  pending "* / % are left-associative" do
+    (2*1/2).should     == (2*1)/2
+    # Guard against the Mathn library
+    # TODO: Make these specs not rely on specific behaviour / result values
+    # by using mocks.
+    conflicts_with :Prime do
+      (2*1/2).should_not == 2*(1/2)
+    end
+
+    (10/7/5).should     == (10/7)/5
+    (10/7/5).should_not == 10/(7/5)
+
+    (101 % 55 % 7).should     == (101 % 55) % 7
+    (101 % 55 % 7).should_not == 101 % (55 % 7)
+
+    (50*20/7%42).should     == ((50*20)/7)%42
+    (50*20/7%42).should_not == 50*(20/(7%42))
+  end
+
+  it "* / % have higher precedence than + -" do
+    (2+2*2).should == 6
+    (1+10/5).should == 3
+    (2+10%5).should == 2
+
+    (2-2*2).should == -2
+    (1-10/5).should == -1
+    (10-10%4).should == 8
+  end
+
+  pending "+ - are left-associative" do
+    (2-3-4).should == -5
+    (4-3+2).should == 3
+
+    class BinaryPlusTest < String; alias_method :plus, :+; def +(a); plus(a) + "!"; end; end
+    s = BinaryPlusTest.new("a")
+
+    (s+s+s).should == (s+s)+s
+    (s+s+s).should_not == s+(s+s)
+  end
+
+  pending "+ - have higher precedence than >> <<" do
+    (2<<1+2).should == 16
+    (8>>1+2).should == 1
+    (4<<1-3).should == 1
+    (2>>1-3).should == 8
+  end
+
+  it ">> << are left-associative" do
+    (1 << 2 << 3).should == 32
+    (10 >> 1 >> 1).should == 2
+    (10 << 4 >> 1).should == 80
+  end
+
+  it ">> << have higher precedence than &" do
+    (4 & 2 << 1).should == 4
+    (2 & 4 >> 1).should == 2
+  end
+
+  pending "& is left-associative" do
+    class BitwiseAndTest; def &(a); a+1; end; end
+    c = BitwiseAndTest.new
+
+    (c & 5 & 2).should     == (c & 5) & 2
+    (c & 5 & 2).should_not == c & (5 & 2)
+  end
+
+  it "& has higher precedence than ^ |" do
+    (8 ^ 16 & 16).should == 24
+    (8 | 16 & 16).should == 24
+  end
+
+  pending "^ | are left-associative" do
+    class OrAndXorTest; def ^(a); a+10; end; def |(a); a-10; end; end
+    d = OrAndXorTest.new
+
+    (d ^ 13 ^ 16).should     == (d ^ 13) ^ 16
+    (d ^ 13 ^ 16).should_not == d ^ (13 ^ 16)
+
+    (d | 13 | 4).should     == (d | 13) | 4
+    (d | 13 | 4).should_not == d | (13 | 4)
+  end
+
+  it "^ | have higher precedence than <= < > >=" do
+    (10 <= 7 ^ 7).should == false
+    (10 < 7 ^ 7).should == false
+    (10 > 7 ^ 7).should == true
+    (10 >= 7 ^ 7).should == true
+    (10 <= 7 | 7).should == false
+    (10 < 7 | 7).should == false
+    (10 > 7 | 7).should == true
+    (10 >= 7 | 7).should == true
+  end
+
+  pending "<= < > >= are left-associative" do
+    class ComparisonTest
+      def <=(a); 0; end;
+      def <(a);  0; end;
+      def >(a);  0; end;
+      def >=(a); 0; end;
+    end
+
+    e = ComparisonTest.new
+
+    (e <= 0 <= 1).should     == (e <= 0) <= 1
+    (e <= 0 <= 1).should_not == e <= (0 <= 1)
+
+    (e < 0 < 1).should     == (e < 0) < 1
+    (e < 0 < 1).should_not == e < (0 < 1)
+
+    (e >= 0 >= 1).should     == (e >= 0) >= 1
+    (e >= 0 >= 1).should_not == e >= (0 >= 1)
+
+    (e > 0 > 1).should     == (e > 0) > 1
+    (e > 0 > 1).should_not == e > (0 > 1)
+  end
+
+  ruby_version_is "" ... "1.9" do
+    it "<= < > >= have higher precedence than <=> == === != =~ !~" do
+      (1 <=> 5 <  1).should == nil
+      (1 <=> 5 <= 1).should == nil
+      (1 <=> 5 >  1).should == nil
+      (1 <=> 5 >= 1).should == nil
+
+      (1 == 5 <  1).should == false
+      (1 == 5 <= 1).should == false
+      (1 == 5 >  1).should == false
+      (1 == 5 >= 1).should == false
+
+      (1 === 5 <  1).should == false
+      (1 === 5 <= 1).should == false
+      (1 === 5 >  1).should == false
+      (1 === 5 >= 1).should == false
+
+      (1 != 5 <  1).should == true
+      (1 != 5 <= 1).should == true
+      (1 != 5 >  1).should == true
+      (1 != 5 >= 1).should == true
+
+      (1 =~ 5 <  1).should == false
+      (1 =~ 5 <= 1).should == false
+      (1 =~ 5 >  1).should == false
+      (1 =~ 5 >= 1).should == false
+
+      (1 !~ 5 <  1).should == true
+      (1 !~ 5 <= 1).should == true
+      (1 !~ 5 >  1).should == true
+      (1 !~ 5 >= 1).should == true
+    end
+  end
+
+  it "<=> == === != =~ !~ are non-associative" do
+    lambda { eval("1 <=> 2 <=> 3")  }.should raise_error(SyntaxError)
+    lambda { eval("1 == 2 == 3")  }.should raise_error(SyntaxError)
+    lambda { eval("1 === 2 === 3")  }.should raise_error(SyntaxError)
+    lambda { eval("1 != 2 != 3")  }.should raise_error(SyntaxError)
+    lambda { eval("1 =~ 2 =~ 3")  }.should raise_error(SyntaxError)
+    lambda { eval("1 !~ 2 !~ 3")  }.should raise_error(SyntaxError)
+  end
+
+  pending "<=> == === != =~ !~ have higher precedence than &&" do
+    (false && 2 <=> 3).should == false
+    (false && 3 == false).should == false
+    (false && 3 === false).should == false
+    (false && 3 != true).should == false
+
+    class FalseClass; def =~(o); o == false; end; end
+    (false && true =~ false).should     == (false && (true =~ false))
+    (false && true =~ false).should_not == ((false && true) =~ false)
+    class FalseClass; undef_method :=~; end
+
+    (false && true !~ true).should == false
+  end
+
+  # XXX: figure out how to test it
+  # (a && b) && c equals to a && (b && c) for all a,b,c values I can imagine so far
+  pending "&& is left-associative"
+
+  it "&& has higher precedence than ||" do
+    (true || false && false).should == true
+  end
+
+  # XXX: figure out how to test it
+  pending "|| is left-associative"
+
+  it "|| has higher precedence than .. ..." do
+    (1..false||10).should == (1..10)
+    (1...false||10).should == (1...10)
+  end
+
+  it ".. ... are non-associative" do
+    lambda { eval("1..2..3")  }.should raise_error(SyntaxError)
+    lambda { eval("1...2...3")  }.should raise_error(SyntaxError)
+  end
+
+# XXX: this is commented now due to a bug in compiler, which cannot
+# distinguish between range and flip-flop operator so far. zenspider is
+# currently working on a new lexer, which will be able to do that.
+# As soon as it's done, these piece should be reenabled.
+#
+#  it ".. ... have higher precedence than ? :" do
+#    (1..2 ? 3 : 4).should == 3
+#    (1...2 ? 3 : 4).should == 3
+#  end
+
+  it "? : is right-associative" do
+    (true ? 2 : 3 ? 4 : 5).should == 2
+  end
+
+  def oops; raise end
+
+  pending "? : has higher precedence than rescue" do
+
+    (true ? oops : 0 rescue 10).should == 10
+  end
+
+  # XXX: figure how to test it (problem similar to || associativity)
+  pending "rescue is left-associative"
+
+  pending "rescue has higher precedence than =" do
+    # a = oops rescue 10
+    a.should == 10
+
+    # rescue doesn't have the same sense for %= /= and friends
+  end
+
+  pending "= %= /= -= += |= &= >>= <<= *= &&= ||= **= are right-associative" do
+    # a = b = 10
+    # a.should == 10
+    # b.should == 10
+
+    # a = b = 10
+    # a %= b %= 3
+    # a.should == 0
+    # b.should == 1
+
+    # a = b = 10
+    # a /= b /= 2
+    # a.should == 2
+    # b.should == 5
+
+    # a = b = 10
+    # a -= b -= 2
+    # a.should == 2
+    # b.should == 8
+
+    # a = b = 10
+    # a += b += 2
+    # a.should == 22
+    # b.should == 12
+
+    # a,b = 32,64
+    # a |= b |= 2
+    # a.should == 98
+    # b.should == 66
+
+    # a,b = 25,13
+    # a &= b &= 7
+    # a.should == 1
+    # b.should == 5
+
+    # a,b=8,2
+    # a >>= b >>= 1
+    # a.should == 4
+    # b.should == 1
+
+    # a,b=8,2
+    # a <<= b <<= 1
+    # a.should == 128
+    # b.should == 4
+
+    # a,b=8,2
+    # a *= b *= 2
+    # a.should == 32
+    # b.should == 4
+
+    # a,b=10,20
+    # a &&= b &&= false
+    # a.should == false
+    # b.should == false
+
+    # a,b=nil,nil
+    # a ||= b ||= 10
+    # a.should == 10
+    # b.should == 10
+
+    # a,b=2,3
+    # a **= b **= 2
+    # a.should == 512
+    # b.should == 9
+  end
+
+  pending "= %= /= -= += |= &= >>= <<= *= &&= ||= **= have higher precedence than defined? operator" do
+    # (defined? a =   10).should == "assignment"
+    # (defined? a %=  10).should == "assignment"
+    # (defined? a /=  10).should == "assignment"
+    # (defined? a -=  10).should == "assignment"
+    # (defined? a +=  10).should == "assignment"
+    # (defined? a |=  10).should == "assignment"
+    # (defined? a &=  10).should == "assignment"
+    # (defined? a >>= 10).should == "assignment"
+    # (defined? a <<= 10).should == "assignment"
+    # (defined? a *=  10).should == "assignment"
+    # (defined? a &&= 10).should == "assignment"
+    # (defined? a ||= 10).should == "assignment"
+    # (defined? a **= 10).should == "assignment"
+  end
+
+  # XXX: figure out how to test it
+  pending "defined? is non-associative"
+
+  it "defined? has higher precedence than not" do
+    # does it have sense?
+    (not defined? qqq).should == true
+  end
+
+  it "not is right-associative" do
+    (not not false).should == false
+    (not not 10).should == true
+  end
+
+  it "not has higher precedence than or/and" do
+    (not false and false).should == false
+    (not false or true).should == true
+  end
+
+  # XXX: figure out how to test it
+  pending "or/and are left-associative"
+
+  pending "or/and have higher precedence than if unless while until modifiers" do
+    (1 if 2 and 3).should == 1
+    (1 if 2 or 3).should == 1
+
+    (1 unless false and true).should == 1
+    (1 unless false or false).should == 1
+
+    (1 while true and false).should == nil    # would hang upon error
+    (1 while false or false).should == nil
+
+    ((raise until true and false) rescue 10).should == 10
+    (1 until false or true).should == nil    # would hang upon error
+  end
+
+  # XXX: it seems to me they are right-associative
+  pending "if unless while until are non-associative"
+end