tweak syntax

Author: dorianmariecom

lib/code/parser/call.rb

@@ -59,6 +59,10 @@ def do_keyword
         str("do")
       end
 
+      def begin_keyword
+        str("do")
+      end
+
       def end_keyword
         str("end")
       end
@@ -107,8 +111,9 @@ def parameters
 
       def block
         (
-          do_keyword << whitespace? << parameters.aka(:parameters).maybe <<
-            code.aka(:body) << end_keyword.maybe
+          (do_keyword | begin_keyword) << whitespace? <<
+            parameters.aka(:parameters).maybe << code.aka(:body) <<
+            end_keyword.maybe
         ) |
           (
             opening_curly_bracket << whitespace? <<

lib/code/parser/class.rb

@@ -7,41 +7,8 @@ def statement
         While
       end
 
-      def name
-        Name
-      end
-
-      def code
-        Code
-      end
-
-      def whitespace
-        Whitespace
-      end
-
-      def whitespace?
-        whitespace.maybe
-      end
-
-      def class_keyword
-        str("class")
-      end
-
-      def end_keyword
-        str("end")
-      end
-
-      def lesser
-        str("<")
-      end
-
       def root
-        (
-          class_keyword << whitespace? << name.aka(:name) <<
-            (
-              whitespace? << lesser << whitespace? << name.aka(:superclass)
-            ).maybe << code.aka(:body) << end_keyword.maybe
-        ).aka(:class) | statement
+        statement
       end
     end
   end

lib/code/parser/function.rb

@@ -23,6 +23,18 @@ def whitespace?
         whitespace.maybe
       end
 
+      def do_keyword
+        str("do")
+      end
+
+      def begin_keyword
+        str("begin")
+      end
+
+      def end_keyword
+        str("end")
+      end
+
       def opening_parenthesis
         str("(")
       end
@@ -88,11 +100,15 @@ def parameters
           (whitespace? << closing_parenthesis.ignore).maybe
       end
 
+      def body
+        ((begin_keyword | do_keyword) << code << end_keyword.maybe) |
+          (opening_curly_bracket << code << closing_curly_bracket.maybe) | code
+      end
+
       def root
         (
           parameters.aka(:parameters) << whitespace? << equal << greater <<
-            whitespace? << opening_curly_bracket << code.aka(:body) <<
-            closing_curly_bracket.maybe
+            whitespace? << body.aka(:body)
         ).aka(:function) | Dictionary
       end
     end

lib/code/parser/group.rb

@@ -15,8 +15,22 @@ def closing_parenthesis
         str(")")
       end
 
+      def end_keyword
+        str("end")
+      end
+
+      def do_keyword
+        str("do")
+      end
+
+      def begin_keyword
+        str("begin")
+      end
+
       def root
         (opening_parenthesis << code << closing_parenthesis.maybe).aka(:group) |
+          (begin_keyword << code << end_keyword.maybe).aka(:group) |
+          (do_keyword << code << end_keyword.maybe).aka(:group) |
           Call
       end
     end

lib/code/parser/if.rb

@@ -23,6 +23,22 @@ def whitespace?
         whitespace.maybe
       end
 
+      def do_keyword
+        str("do")
+      end
+
+      def begin_keyword
+        str("begin")
+      end
+
+      def opening_curly_bracket
+        str("{")
+      end
+
+      def closing_curly_bracket
+        str("{")
+      end
+
       def if_keyword
         str("if")
       end
@@ -43,20 +59,25 @@ def end_keyword
         str("end")
       end
 
+      def body
+        ((begin_keyword | do_keyword) << code << end_keyword.maybe) |
+          (opening_curly_bracket << code << closing_curly_bracket.maybe) | code
+      end
+
       def root
         (
           (if_keyword | unless_keyword).aka(:first_operator) << whitespace <<
-            statement.aka(:first_statement) << code.aka(:first_body) <<
+            statement.aka(:first_statement) << body.aka(:first_body) <<
             (
               (
                 elsif_keyword.aka(:operator) << whitespace <<
-                  statement.aka(:statement) << code.aka(:body)
+                  statement.aka(:statement) << body.aka(:body)
               ) |
                 (
                   else_keyword << whitespace <<
                     (if_keyword | unless_keyword).aka(:operator) <<
-                    whitespace << statement.aka(:statement) << code.aka(:body)
-                ) | (else_keyword.aka(:operator) << code.aka(:body))
+                    whitespace << statement.aka(:statement) << body.aka(:body)
+                ) | (else_keyword.aka(:operator) << body.aka(:body))
             ).repeat(1).aka(:elses).maybe << end_keyword.maybe
         ).aka(:if) | statement
       end

lib/code/parser/name.rb

@@ -91,10 +91,18 @@ def elsif_keyword
         str("elsif")
       end
 
+      def begin_keyword
+        str("begin")
+      end
+
       def else_keyword
         str("else")
       end
 
+      def begin_keyword
+        str("begin")
+      end
+
       def special_character
         ampersand | equal | pipe | dot | colon | comma | space | newline |
           opening_curly_bracket | closing_curly_bracket | opening_parenthesis |
@@ -113,8 +121,9 @@ def separator
 
       def root
         (do_keyword << separator).absent << (
-          else_keyword << separator
-        ).absent << (elsif_keyword << separator).absent <<
+          begin_keyword << separator
+        ).absent << (else_keyword << separator).absent <<
+          (elsif_keyword << separator).absent <<
           (end_keyword << separator).absent << character.repeat(1)
       end
     end

lib/code/parser/while.rb

@@ -35,6 +35,10 @@ def do_keyword
         str("do")
       end
 
+      def begin_keyword
+        str("begin")
+      end
+
       def loop_keyword
         str("loop")
       end
@@ -47,19 +51,19 @@ def closing_curly_bracket
         str("}")
       end
 
+      def body
+        ((do_keyword | begin_keyword) << code << end_keyword.maybe) |
+          (opening_curly_bracket << code << closing_curly_bracket) | code
+      end
+
       def root
         (
           (
             (
               (while_keyword | until_keyword).aka(:operator) << whitespace <<
                 statement.aka(:statement)
             ) | (loop_keyword.aka(:operator) << whitespace)
-          ) << (
-            (
-              whitespace? << (opening_curly_bracket | do_keyword)
-            ).maybe << code.aka(:body) <<
-              (closing_curly_bracket | end_keyword).maybe
-          )
+          ) << body.aka(:body)
         ).aka(:while) | statement
       end
     end

spec/code_spec.rb

@@ -353,6 +353,8 @@
       next if code_input.is_a?(Code::Object::Decimal)
 
       expect(code_input.to_json).to eq(code_expected.to_json)
+      YAML.unsafe_load(code_input.to_yaml)
+      YAML.unsafe_load(code_expected.to_yaml)
     end
   end