Transition ruby test fixtures

test/fixtures/ruby/and-or.A.rb

@@ -1,3 +1 @@
-foo and bar
-bar or foo
-bar and foo
+foo and bar

test/fixtures/ruby/and-or.B.rb

@@ -1 +1,2 @@
 foo or bar
+a or b and c

test/fixtures/ruby/and-or.diffA-B.txt

@@ -7,11 +7,10 @@
     (Identifier)
     (Other "or")
     (Identifier)) }
-{-(Binary
-    (Identifier)
-    (Other "or")
-    (Identifier))-}
-{-(Binary
-    (Identifier)
+{+(Binary
+    (Binary
+      (Identifier)
+      (Other "or")
+      (Identifier))
     (Other "and")
-    (Identifier))-})
+    (Identifier))+})

test/fixtures/ruby/and-or.diffB-A.txt

@@ -1,15 +1,16 @@
 (Program
-{+(Binary
+{ (Binary
     (Identifier)
-    (Other "and")
-    (Identifier))+}
-  (Binary
-  { (Identifier)
-  ->(Identifier) }
     (Other "or")
-  { (Identifier)
-  ->(Identifier) })
-{+(Binary
+    (Identifier))
+->(Binary
     (Identifier)
     (Other "and")
-    (Identifier))+})
+    (Identifier)) }
+{-(Binary
+    (Binary
+      (Identifier)
+      (Other "or")
+      (Identifier))
+    (Other "and")
+    (Identifier))-})

test/fixtures/ruby/and-or.parseA.txt

@@ -2,12 +2,4 @@
   (Binary
     (Identifier)
     (Other "and")
-    (Identifier))
-  (Binary
-    (Identifier)
-    (Other "or")
-    (Identifier))
-  (Binary
-    (Identifier)
-    (Other "and")
-    (Identifier)))
+    (Identifier)))

test/fixtures/ruby/and-or.parseB.txt

@@ -2,4 +2,11 @@
   (Binary
     (Identifier)
     (Other "or")
-    (Identifier)))
+    (Identifier))
+  (Binary
+    (Binary
+      (Identifier)
+      (Other "or")
+      (Identifier))
+    (Other "and")
+    (Identifier)))

test/fixtures/ruby/array.A.rb

@@ -0,0 +1 @@
+[ 1, 2, 3]

test/fixtures/ruby/array.B.rb

@@ -0,0 +1 @@
+['a', 'b', 'c']

test/fixtures/ruby/array.diffA-B.txt

@@ -0,0 +1,8 @@
+(Program
+  (ArrayLiteral
+  {+(StringLiteral)+}
+  {+(StringLiteral)+}
+  {+(StringLiteral)+}
+  {-(IntegerLiteral)-}
+  {-(IntegerLiteral)-}
+  {-(IntegerLiteral)-}))

test/fixtures/ruby/array.diffB-A.txt

@@ -0,0 +1,8 @@
+(Program
+  (ArrayLiteral
+  {+(IntegerLiteral)+}
+  {+(IntegerLiteral)+}
+  {+(IntegerLiteral)+}
+  {-(StringLiteral)-}
+  {-(StringLiteral)-}
+  {-(StringLiteral)-}))

test/fixtures/ruby/array.parseA.txt

@@ -0,0 +1,5 @@
+(Program
+  (ArrayLiteral
+    (IntegerLiteral)
+    (IntegerLiteral)
+    (IntegerLiteral)))

test/fixtures/ruby/array.parseB.txt

@@ -0,0 +1,5 @@
+(Program
+  (ArrayLiteral
+    (StringLiteral)
+    (StringLiteral)
+    (StringLiteral)))

test/fixtures/ruby/assignment.A.rb

@@ -0,0 +1 @@
+x = 0

test/fixtures/ruby/assignment.B.rb

@@ -0,0 +1 @@
+x = 1

test/fixtures/ruby/assignment.diffA-B.txt

@@ -0,0 +1,5 @@
+(Program
+  (Assignment
+    (Identifier)
+  { (IntegerLiteral)
+  ->(IntegerLiteral) }))

test/fixtures/ruby/assignment.diffB-A.txt

@@ -0,0 +1,5 @@
+(Program
+  (Assignment
+    (Identifier)
+  { (IntegerLiteral)
+  ->(IntegerLiteral) }))

test/fixtures/ruby/assignment.parseA.txt

@@ -0,0 +1,4 @@
+(Program
+  (Assignment
+    (Identifier)
+    (IntegerLiteral)))

test/fixtures/ruby/assignment.parseB.txt

@@ -0,0 +1,4 @@
+(Program
+  (Assignment
+    (Identifier)
+    (IntegerLiteral)))

test/fixtures/ruby/begin-block.A.rb

@@ -0,0 +1,3 @@
+BEGIN {
+ foo
+}

test/fixtures/ruby/begin-block.B.rb

@@ -0,0 +1,4 @@
+foo
+BEGIN {
+ bar
+}

test/fixtures/ruby/begin-block.diffA-B.txt

@@ -0,0 +1,5 @@
+(Program
+{+(Identifier)+}
+  (BeginBlock
+  { (Identifier)
+  ->(Identifier) }))

test/fixtures/ruby/begin-block.diffB-A.txt

@@ -0,0 +1,6 @@
+(Program
+{+(BeginBlock
+    (Identifier))+}
+{-(Identifier)-}
+{-(BeginBlock
+    (Identifier))-})

test/fixtures/ruby/begin-block.parseA.txt

@@ -0,0 +1,3 @@
+(Program
+  (BeginBlock
+    (Identifier)))

test/fixtures/ruby/begin-block.parseB.txt

@@ -0,0 +1,4 @@
+(Program
+  (Identifier)
+  (BeginBlock
+    (Identifier)))

test/fixtures/ruby/begin.A.rb

@@ -0,0 +1,4 @@
+def foo
+begin
+end
+end

test/fixtures/ruby/begin.B.rb

@@ -0,0 +1,5 @@
+def foo
+begin
+  puts 'hi'
+end
+end

test/fixtures/ruby/begin.diffA-B.txt

@@ -0,0 +1,7 @@
+(Program
+  (Method
+    (Identifier)
+    (Begin
+    {+(MethodCall
+        (Identifier)
+        (StringLiteral))+})))

test/fixtures/ruby/begin.diffB-A.txt

@@ -0,0 +1,7 @@
+(Program
+  (Method
+    (Identifier)
+    (Begin
+    {-(MethodCall
+        (Identifier)
+        (StringLiteral))-})))

test/fixtures/ruby/begin.parseA.txt

@@ -0,0 +1,4 @@
+(Program
+  (Method
+    (Identifier)
+    (Begin)))

test/fixtures/ruby/begin.parseB.txt

@@ -0,0 +1,7 @@
+(Program
+  (Method
+    (Identifier)
+    (Begin
+      (MethodCall
+        (Identifier)
+        (StringLiteral)))))

test/fixtures/ruby/bitwise-operator.A.rb

@@ -0,0 +1,3 @@
+a | b
+a >> b
+a ^ b

test/fixtures/ruby/bitwise-operator.B.rb

@@ -0,0 +1,2 @@
+a & b
+a << b

test/fixtures/ruby/bitwise-operator.diffA-B.txt

@@ -0,0 +1,21 @@
+(Program
+{ (Binary
+    (Identifier)
+    (Other "|")
+    (Identifier))
+->(Binary
+    (Identifier)
+    (Other "&")
+    (Identifier)) }
+{ (Binary
+    (Identifier)
+    (Other ">>")
+    (Identifier))
+->(Binary
+    (Identifier)
+    (Other "<<")
+    (Identifier)) }
+{-(Binary
+    (Identifier)
+    (Other "^")
+    (Identifier))-})

test/fixtures/ruby/bitwise-operator.diffB-A.txt

@@ -0,0 +1,21 @@
+(Program
+{ (Binary
+    (Identifier)
+    (Other "&")
+    (Identifier))
+->(Binary
+    (Identifier)
+    (Other "|")
+    (Identifier)) }
+{ (Binary
+    (Identifier)
+    (Other "<<")
+    (Identifier))
+->(Binary
+    (Identifier)
+    (Other ">>")
+    (Identifier)) }
+{+(Binary
+    (Identifier)
+    (Other "^")
+    (Identifier))+})

test/fixtures/ruby/bitwise-operator.parseA.txt

@@ -0,0 +1,13 @@
+(Program
+  (Binary
+    (Identifier)
+    (Other "|")
+    (Identifier))
+  (Binary
+    (Identifier)
+    (Other ">>")
+    (Identifier))
+  (Binary
+    (Identifier)
+    (Other "^")
+    (Identifier)))

test/fixtures/ruby/bitwise-operator.parseB.txt

@@ -0,0 +1,9 @@
+(Program
+  (Binary
+    (Identifier)
+    (Other "&")
+    (Identifier))
+  (Binary
+    (Identifier)
+    (Other "<<")
+    (Identifier)))

test/fixtures/ruby/boolean-operator.A.rb

@@ -0,0 +1 @@
+a || b

test/fixtures/ruby/boolean-operator.B.rb

@@ -0,0 +1 @@
+a && b

test/fixtures/ruby/boolean-operator.diffA-B.txt

@@ -0,0 +1,9 @@
+(Program
+{ (Binary
+    (Identifier)
+    (Other "||")
+    (Identifier))
+->(Binary
+    (Identifier)
+    (Other "&&")
+    (Identifier)) })

test/fixtures/ruby/boolean-operator.diffB-A.txt

@@ -0,0 +1,9 @@
+(Program
+{ (Binary
+    (Identifier)
+    (Other "&&")
+    (Identifier))
+->(Binary
+    (Identifier)
+    (Other "||")
+    (Identifier)) })

test/fixtures/ruby/boolean-operator.parseA.txt

@@ -0,0 +1,5 @@
+(Program
+  (Binary
+    (Identifier)
+    (Other "||")
+    (Identifier)))

test/fixtures/ruby/boolean-operator.parseB.txt

@@ -0,0 +1,5 @@
+(Program
+  (Binary
+    (Identifier)
+    (Other "&&")
+    (Identifier)))

test/fixtures/ruby/class.A.rb

@@ -0,0 +1,3 @@
+class Foo < Super
+  def test; end
+end

test/fixtures/ruby/class.B.rb

@@ -0,0 +1,3 @@
+class Foo
+  def test; end
+end

test/fixtures/ruby/class.diffA-B.txt

@@ -0,0 +1,7 @@
+(Program
+  (Class
+    (Constant)
+  {-(Superclass
+      (Constant))-}
+    (Method
+      (Identifier))))

test/fixtures/ruby/class.diffB-A.txt

@@ -0,0 +1,7 @@
+(Program
+  (Class
+    (Constant)
+  {+(Superclass
+      (Constant))+}
+    (Method
+      (Identifier))))

test/fixtures/ruby/class.parseA.txt

@@ -0,0 +1,7 @@
+(Program
+  (Class
+    (Constant)
+    (Superclass
+      (Constant))
+    (Method
+      (Identifier))))

test/fixtures/ruby/class.parseB.txt

@@ -0,0 +1,5 @@
+(Program
+  (Class
+    (Constant)
+    (Method
+      (Identifier))))

test/fixtures/ruby/comment.A.rb

@@ -0,0 +1 @@
+# This is a comment

test/fixtures/ruby/comment.B.rb

@@ -0,0 +1,4 @@
+=begin
+This is a multiline
+comment
+=end

test/fixtures/ruby/comment.diffA-B.txt

@@ -0,0 +1,14 @@
+(Program
+{+(ParseError
+    (Other "right_assignment_list"
+      (Begin
+        (MethodCall
+          (Constant)
+          (MethodCall
+            (Identifier)
+            (MethodCall
+              (Identifier)
+              (Identifier))))
+        (Identifier)
+        (ParseError))))+}
+{-(Comment)-})

test/fixtures/ruby/comment.diffB-A.txt

@@ -0,0 +1,14 @@
+(Program
+{+(Comment)+}
+{-(ParseError
+    (Other "right_assignment_list"
+      (Begin
+        (MethodCall
+          (Constant)
+          (MethodCall
+            (Identifier)
+            (MethodCall
+              (Identifier)
+              (Identifier))))
+        (Identifier)
+        (ParseError))))-})

test/fixtures/ruby/comment.parseA.txt

@@ -0,0 +1,2 @@
+(Program
+  (Comment))

test/fixtures/ruby/comment.parseB.txt

@@ -0,0 +1,13 @@
+(Program
+  (ParseError
+    (Other "right_assignment_list"
+      (Begin
+        (MethodCall
+          (Constant)
+          (MethodCall
+            (Identifier)
+            (MethodCall
+              (Identifier)
+              (Identifier))))
+        (Identifier)
+        (ParseError)))))

test/fixtures/ruby/comparision-operator.A.rb

@@ -0,0 +1,2 @@
+x < y
+a > b

test/fixtures/ruby/comparision-operator.B.rb

@@ -0,0 +1,2 @@
+x <= y
+a >= b

test/fixtures/ruby/comparision-operator.diffA-B.txt

@@ -0,0 +1,17 @@
+(Program
+{ (Binary
+    (Identifier)
+    (Other "<")
+    (Identifier))
+->(Binary
+    (Identifier)
+    (Other "<=")
+    (Identifier)) }
+{ (Binary
+    (Identifier)
+    (Other ">")
+    (Identifier))
+->(Binary
+    (Identifier)
+    (Other ">=")
+    (Identifier)) })

test/fixtures/ruby/comparision-operator.diffB-A.txt

@@ -0,0 +1,17 @@
+(Program
+{ (Binary
+    (Identifier)
+    (Other "<=")
+    (Identifier))
+->(Binary
+    (Identifier)
+    (Other "<")
+    (Identifier)) }
+{ (Binary
+    (Identifier)
+    (Other ">=")
+    (Identifier))
+->(Binary
+    (Identifier)
+    (Other ">")
+    (Identifier)) })

test/fixtures/ruby/comparision-operator.parseA.txt

@@ -0,0 +1,9 @@
+(Program
+  (Binary
+    (Identifier)
+    (Other "<")
+    (Identifier))
+  (Binary
+    (Identifier)
+    (Other ">")
+    (Identifier)))

test/fixtures/ruby/comparision-operator.parseB.txt

@@ -0,0 +1,9 @@
+(Program
+  (Binary
+    (Identifier)
+    (Other "<=")
+    (Identifier))
+  (Binary
+    (Identifier)
+    (Other ">=")
+    (Identifier)))

test/fixtures/ruby/conditional-assignment.A.rb

@@ -0,0 +1 @@
+x ||= 5

test/fixtures/ruby/conditional-assignment.B.rb

@@ -0,0 +1 @@
+x &&= 7

test/fixtures/ruby/conditional-assignment.diffA-B.txt

@@ -0,0 +1,5 @@
+(Program
+  (OperatorAssignment
+    (Identifier)
+  { (IntegerLiteral)
+  ->(IntegerLiteral) }))

test/fixtures/ruby/conditional-assignment.diffB-A.txt

@@ -0,0 +1,5 @@
+(Program
+  (OperatorAssignment
+    (Identifier)
+  { (IntegerLiteral)
+  ->(IntegerLiteral) }))

test/fixtures/ruby/conditional-assignment.parseA.txt

@@ -0,0 +1,4 @@
+(Program
+  (OperatorAssignment
+    (Identifier)
+    (IntegerLiteral)))

test/fixtures/ruby/conditional-assignment.parseB.txt

@@ -0,0 +1,4 @@
+(Program
+  (OperatorAssignment
+    (Identifier)
+    (IntegerLiteral)))

test/fixtures/ruby/delimiter.A.rb

@@ -0,0 +1,6 @@
+%q#a#
+%q<a<b>c>
+%#a#
+%Q#a#
+%<a<b>c>
+%Q<a<b>c>

test/fixtures/ruby/delimiter.B.rb

@@ -0,0 +1,6 @@
+%q/b/
+%q{d{e}f}
+%/b/
+%Q/b/
+%{d{e}f}
+%Q{d{e}f}

test/fixtures/ruby/delimiter.diffA-B.txt

@@ -0,0 +1,13 @@
+(Program
+{+(StringLiteral)+}
+{+(StringLiteral)+}
+{ (StringLiteral)
+->(StringLiteral) }
+{+(StringLiteral)+}
+{+(StringLiteral)+}
+{+(StringLiteral)+}
+{-(StringLiteral)-}
+{-(StringLiteral)-}
+{-(StringLiteral)-}
+{-(StringLiteral)-}
+{-(StringLiteral)-})

test/fixtures/ruby/delimiter.diffB-A.txt

@@ -0,0 +1,13 @@
+(Program
+{+(StringLiteral)+}
+{ (StringLiteral)
+->(StringLiteral) }
+{+(StringLiteral)+}
+{ (StringLiteral)
+->(StringLiteral) }
+{+(StringLiteral)+}
+{+(StringLiteral)+}
+{-(StringLiteral)-}
+{-(StringLiteral)-}
+{-(StringLiteral)-}
+{-(StringLiteral)-})

test/fixtures/ruby/delimiter.parseA.txt

@@ -0,0 +1,7 @@
+(Program
+  (StringLiteral)
+  (StringLiteral)
+  (StringLiteral)
+  (StringLiteral)
+  (StringLiteral)
+  (StringLiteral))

test/fixtures/ruby/delimiter.parseB.txt

@@ -0,0 +1,7 @@
+(Program
+  (StringLiteral)
+  (StringLiteral)
+  (StringLiteral)
+  (StringLiteral)
+  (StringLiteral)
+  (StringLiteral))

test/fixtures/ruby/element-reference.A.rb

@@ -0,0 +1,3 @@
+foo[bar]
+foo[:bar]
+foo[bar] = 1

test/fixtures/ruby/element-reference.B.rb

@@ -0,0 +1,2 @@
+x["b"]
+x[:"c"]

test/fixtures/ruby/element-reference.diffA-B.txt

@@ -0,0 +1,17 @@
+(Program
+{ (SubscriptAccess
+    (Identifier)
+    (Identifier))
+->(SubscriptAccess
+    (Identifier)
+    (StringLiteral)) }
+  (SubscriptAccess
+  { (Identifier)
+  ->(Identifier) }
+  { (SymbolLiteral)
+  ->(SymbolLiteral) })
+{-(Assignment
+    (SubscriptAccess
+      (Identifier)
+      (Identifier))
+    (IntegerLiteral))-})

test/fixtures/ruby/element-reference.diffB-A.txt

@@ -0,0 +1,17 @@
+(Program
+{ (SubscriptAccess
+    (Identifier)
+    (StringLiteral))
+->(SubscriptAccess
+    (Identifier)
+    (Identifier)) }
+  (SubscriptAccess
+  { (Identifier)
+  ->(Identifier) }
+  { (SymbolLiteral)
+  ->(SymbolLiteral) })
+{+(Assignment
+    (SubscriptAccess
+      (Identifier)
+      (Identifier))
+    (IntegerLiteral))+})

test/fixtures/ruby/element-reference.parseA.txt

@@ -0,0 +1,12 @@
+(Program
+  (SubscriptAccess
+    (Identifier)
+    (Identifier))
+  (SubscriptAccess
+    (Identifier)
+    (SymbolLiteral))
+  (Assignment
+    (SubscriptAccess
+      (Identifier)
+      (Identifier))
+    (IntegerLiteral)))

test/fixtures/ruby/element-reference.parseB.txt

@@ -0,0 +1,7 @@
+(Program
+  (SubscriptAccess
+    (Identifier)
+    (StringLiteral))
+  (SubscriptAccess
+    (Identifier)
+    (SymbolLiteral)))

test/fixtures/ruby/else.A.rb

@@ -0,0 +1,4 @@
+begin
+  foo()
+else
+end

test/fixtures/ruby/else.B.rb

@@ -0,0 +1,5 @@
+begin
+  foo()
+else
+  bar()
+end

test/fixtures/ruby/else.diffA-B.txt

@@ -0,0 +1,8 @@
+(Program
+  (Begin
+    (MethodCall
+      (Identifier))
+  { (Else)
+  ->(Else
+      (MethodCall
+        (Identifier))) }))

test/fixtures/ruby/else.diffB-A.txt

@@ -0,0 +1,8 @@
+(Program
+  (Begin
+    (MethodCall
+      (Identifier))
+  { (Else
+      (MethodCall
+        (Identifier)))
+  ->(Else) }))

test/fixtures/ruby/else.parseA.txt

@@ -0,0 +1,5 @@
+(Program
+  (Begin
+    (MethodCall
+      (Identifier))
+    (Else)))

test/fixtures/ruby/else.parseB.txt

@@ -0,0 +1,7 @@
+(Program
+  (Begin
+    (MethodCall
+      (Identifier))
+    (Else
+      (MethodCall
+        (Identifier)))))

test/fixtures/ruby/elsif.A.rb

@@ -0,0 +1,4 @@
+if bar
+  foo()
+elsif baz
+end

test/fixtures/ruby/elsif.B.rb

@@ -0,0 +1,5 @@
+if bar
+  foo()
+elsif baz
+  qoz()
+end

test/fixtures/ruby/elsif.diffA-B.txt

@@ -0,0 +1,9 @@
+(Program
+  (If
+    (Identifier)
+    (MethodCall
+      (Identifier))
+    (Elsif
+      (Identifier)
+    {+(MethodCall
+        (Identifier))+})))

test/fixtures/ruby/elsif.diffB-A.txt

@@ -0,0 +1,9 @@
+(Program
+  (If
+    (Identifier)
+    (MethodCall
+      (Identifier))
+    (Elsif
+      (Identifier)
+    {-(MethodCall
+        (Identifier))-})))

test/fixtures/ruby/elsif.parseA.txt

@@ -0,0 +1,7 @@
+(Program
+  (If
+    (Identifier)
+    (MethodCall
+      (Identifier))
+    (Elsif
+      (Identifier))))

test/fixtures/ruby/elsif.parseB.txt

@@ -0,0 +1,9 @@
+(Program
+  (If
+    (Identifier)
+    (MethodCall
+      (Identifier))
+    (Elsif
+      (Identifier)
+      (MethodCall
+        (Identifier)))))

test/fixtures/ruby/end-block.A.rb

@@ -0,0 +1,3 @@
+END {
+ foo
+}

test/fixtures/ruby/end-block.B.rb

@@ -0,0 +1,4 @@
+foo
+END {
+ bar
+}

test/fixtures/ruby/end-block.diffA-B.txt

@@ -0,0 +1,5 @@
+(Program
+{+(Identifier)+}
+  (EndBlock
+  { (Identifier)
+  ->(Identifier) }))

test/fixtures/ruby/end-block.diffB-A.txt

@@ -0,0 +1,6 @@
+(Program
+{+(EndBlock
+    (Identifier))+}
+{-(Identifier)-}
+{-(EndBlock
+    (Identifier))-})

test/fixtures/ruby/end-block.parseA.txt

@@ -0,0 +1,3 @@
+(Program
+  (EndBlock
+    (Identifier)))

test/fixtures/ruby/end-block.parseB.txt

@@ -0,0 +1,4 @@
+(Program
+  (Identifier)
+  (EndBlock
+    (Identifier)))

test/fixtures/ruby/ensure.A.rb

@@ -0,0 +1,4 @@
+begin
+  foo
+ensure
+end

test/fixtures/ruby/ensure.B.rb

@@ -0,0 +1,5 @@
+begin
+  foo
+ensure
+  bar
+end

test/fixtures/ruby/ensure.diffA-B.txt

@@ -0,0 +1,6 @@
+(Program
+  (Begin
+    (Identifier)
+  { (Ensure)
+  ->(Ensure
+      (Identifier)) }))

test/fixtures/ruby/ensure.diffB-A.txt

@@ -0,0 +1,6 @@
+(Program
+  (Begin
+    (Identifier)
+  { (Ensure
+      (Identifier))
+  ->(Ensure) }))