code-ruby 0.5.6 → 0.6.0

data/lib/code/parser/class.rb

@@ -1,20 +1,22 @@
+# frozen_string_literal: true
+
 class Code
   class Parser
     class Class < Language
       def statement
-        ::Code::Parser::While
+        While
       end
 
       def name
-        ::Code::Parser::Name
+        Name
       end
 
       def code
-        ::Code::Parser::Code
+        Code
       end
 
       def whitespace
-        ::Code::Parser::Whitespace
+        Whitespace
       end
 
       def whitespace?
@@ -36,8 +38,9 @@ class Code
       def root
         (
           class_keyword << whitespace? << name.aka(:name) <<
-          (whitespace? << lesser << name.aka(:superclass)).maybe <<
-          code.aka(:body) << end_keyword.maybe
+            (
+              whitespace? << lesser << whitespace? << name.aka(:superclass)
+            ).maybe << code.aka(:body) << end_keyword.maybe
         ).aka(:class) | statement
       end
     end

data/lib/code/parser/code.rb

@@ -1,16 +1,18 @@
+# frozen_string_literal: true
+
 class Code
   class Parser
     class Code < Language
       def whitespace
-        ::Code::Parser::Whitespace
+        Whitespace
       end
 
-      def whitespace?(&block)
-        whitespace.maybe(&block)
+      def whitespace?
+        whitespace.maybe
       end
 
       def statement
-        ::Code::Parser::Statement
+        Statement
       end
 
       def present

data/lib/code/parser/{dictionnary.rb → dictionary.rb}

@@ -1,20 +1,22 @@
+# frozen_string_literal: true
+
 class Code
   class Parser
-    class Dictionnary < Language
-      def code
-        ::Code::Parser::Code.new.present
+    class Dictionary < Language
+      def code_present
+        Code.new.present
       end
 
       def statement
-        ::Code::Parser::Statement
+        Statement
       end
 
       def name
-        ::Code::Parser::Name
+        Name
       end
 
       def whitespace
-        ::Code::Parser::Whitespace
+        Whitespace
       end
 
       def whitespace?
@@ -46,21 +48,22 @@ class Code
       end
 
       def key_value
-        (name.aka(:name) << colon << code.aka(:value)) |
-          (statement.aka(:statement) << colon << code.aka(:value)) |
+        (name.aka(:name) << colon << code_present.aka(:value).maybe) |
+          (
+            statement.aka(:statement) << colon << code_present.aka(:value).maybe
+          ) |
           (
             statement.aka(:statement) << whitespace? << equal << greater <<
-              code.aka(:value)
-          )
+              code_present.aka(:value).maybe
+          ) | statement.aka(:statement)
       end
 
       def root
         (
           opening_curly_bracket.ignore << whitespace? <<
-            key_value.repeat(0, 1) <<
-            (whitespace? << comma << whitespace? << key_value).repeat <<
+            (whitespace? << key_value << (whitespace? << comma).maybe).repeat <<
             (whitespace? << closing_curly_bracket.ignore).maybe
-        ).aka(:dictionnary) | ::Code::Parser::List
+        ).aka(:dictionnary) | List
       end
     end
   end

data/lib/code/parser/equal.rb

@@ -1,24 +1,10 @@
+# frozen_string_literal: true
+
 class Code
   class Parser
-    class Equal < Language
+    class Equal < RightOperation
       def statement
-        ::Code::Parser::Rescue
-      end
-
-      def name
-        ::Code::Parser::Name
-      end
-
-      def equal_class
-        ::Code::Parser::Equal
-      end
-
-      def whitespace
-        ::Code::Parser::Whitespace
-      end
-
-      def whitespace?
-        whitespace.maybe
+        Rescue
       end
 
       def equal
@@ -70,24 +56,11 @@ class Code
       end
 
       def operator
-        equal.ignore | (plus << equal.ignore) | (minus << equal.ignore) |
-          (asterisk << equal.ignore) | (slash << equal.ignore) |
-          (percent << equal.ignore) | (greater << greater << equal.ignore) |
-          (lesser << lesser << equal.ignore) | (ampersand << equal.ignore) |
-          (pipe << equal.ignore) | (caret << equal.ignore) |
-          (pipe << pipe << equal.ignore) |
-          (ampersand << ampersand << equal.ignore)
-      end
-
-      def names
-        name << (dot << name).repeat
-      end
-
-      def root
-        (
-          names.aka(:left) << whitespace? << operator.aka(:operator) <<
-            whitespace? << equal_class.aka(:right)
-        ).aka(:equal) | statement
+        equal | (plus << equal) | (minus << equal) | (asterisk << equal) |
+          (slash << equal) | (percent << equal) |
+          (greater << greater << equal) | (lesser << lesser << equal) |
+          (ampersand << equal) | (pipe << equal) | (caret << equal) |
+          (pipe << pipe << equal) | (ampersand << ampersand << equal)
       end
     end
   end

data/lib/code/parser/equality.rb

@@ -1,8 +1,10 @@
+# frozen_string_literal: true
+
 class Code
   class Parser
-    class Equality < Operation
+    class Equality < LeftOperation
       def statement
-        ::Code::Parser::Splat
+        Greater
       end
 
       def equal

data/lib/code/parser/function.rb

@@ -1,20 +1,22 @@
+# frozen_string_literal: true
+
 class Code
   class Parser
     class Function < Language
       def name
-        ::Code::Parser::Name
+        Name
       end
 
       def code
-        ::Code::Parser::Code
+        Code
       end
 
       def code_present
-        ::Code::Parser::Code.new.present
+        Code.new.present
       end
 
       def whitespace
-        ::Code::Parser::Whitespace
+        Whitespace
       end
 
       def whitespace?
@@ -53,13 +55,26 @@ class Code
         str("}")
       end
 
+      def asterisk
+        str("*")
+      end
+
+      def ampersand
+        str("&")
+      end
+
+      def prefix
+        (asterisk << asterisk).aka(:keyword_splat) |
+          asterisk.aka(:regular_splat) | ampersand.aka(:block)
+      end
+
       def keyword_parameter
         name.aka(:name) << whitespace? << colon.aka(:keyword) <<
           code_present.aka(:default).maybe
       end
 
       def regular_parameter
-        name.aka(:name) << whitespace? <<
+        prefix.maybe << name.aka(:name) << whitespace? <<
           (equal << whitespace? << code_present.aka(:default)).maybe
       end
 
@@ -68,9 +83,9 @@ class Code
       end
 
       def parameters
-        opening_parenthesis.ignore << whitespace? << parameter.repeat(0, 1) <<
-          (whitespace? << comma << whitespace? << parameter).repeat <<
-          whitespace? << closing_parenthesis.ignore.maybe
+        opening_parenthesis.ignore << whitespace? <<
+          (whitespace? << parameter << (whitespace? << comma).maybe).repeat <<
+          (whitespace? << closing_parenthesis.ignore).maybe
       end
 
       def root
@@ -78,7 +93,7 @@ class Code
           parameters.aka(:parameters) << whitespace? << equal << greater <<
             whitespace? << opening_curly_bracket << code.aka(:body) <<
             closing_curly_bracket.maybe
-        ).aka(:function) | ::Code::Parser::ChainedCall
+        ).aka(:function) | Dictionary
       end
     end
   end

data/lib/code/parser/greater.rb

@@ -1,8 +1,10 @@
+# frozen_string_literal: true
+
 class Code
   class Parser
-    class Greater < Operation
+    class Greater < LeftOperation
       def statement
-        ::Code::Parser::BitwiseOr
+        BitwiseOr
       end
 
       def greater
@@ -18,7 +20,8 @@ class Code
       end
 
       def operator
-        (greater << equal) | (lesser << equal) | greater | lesser
+        (greater << equal) | (lesser << equal << greater.absent) |
+          (greater << equal.absent) | lesser
       end
     end
   end

data/lib/code/parser/group.rb

@@ -1,8 +1,10 @@
+# frozen_string_literal: true
+
 class Code
   class Parser
     class Group < Language
       def code
-        ::Code::Parser::Code
+        Code
       end
 
       def opening_parenthesis
@@ -15,7 +17,7 @@ class Code
 
       def root
         (opening_parenthesis << code << closing_parenthesis.maybe).aka(:group) |
-          ::Code::Parser::Call
+          Call
       end
     end
   end

data/lib/code/parser/if.rb

@@ -1,20 +1,22 @@
+# frozen_string_literal: true
+
 class Code
   class Parser
     class If < Language
       def statement
-        ::Code::Parser::IfModifier
+        IfModifier
       end
 
       def if_class
-        ::Code::Parser::If
+        If
       end
 
       def whitespace
-        ::Code::Parser::Whitespace
+        Whitespace
       end
 
       def code
-        ::Code::Parser::Code
+        Code
       end
 
       def whitespace?

data/lib/code/parser/if_modifier.rb

@@ -1,20 +1,14 @@
+# frozen_string_literal: true
+
 class Code
   class Parser
-    class IfModifier < Language
+    class IfModifier < RightOperation
       def statement
-        ::Code::Parser::OrKeyword
-      end
-
-      def if_modifier
-        ::Code::Parser::IfModifier
+        OrKeyword
       end
 
       def whitespace
-        ::Code::Parser::Whitespace.new.without_newline
-      end
-
-      def whitespace?
-        whitespace.maybe
+        Whitespace.new.without_newline
       end
 
       def if_keyword
@@ -36,20 +30,6 @@ class Code
       def operator
         if_keyword | unless_keyword | while_keyword | until_keyword
       end
-
-      def root
-        (
-          statement.aka(:left) <<
-            (
-              whitespace? << operator.aka(:operator) << whitespace? <<
-                if_modifier.aka(:right)
-            ).maybe
-        )
-          .aka(:if_modifier)
-          .then do |output|
-            output[:if_modifier][:right] ? output : output[:if_modifier][:left]
-          end
-      end
     end
   end
 end

data/lib/code/parser/left_operation.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+class Code
+  class Parser
+    class LeftOperation < Language
+      def statement
+        raise NotImplementedError
+      end
+
+      def whitespace
+        Whitespace
+      end
+
+      def whitespace?
+        whitespace.maybe
+      end
+
+      def operator
+        raise NotImplementedError
+      end
+
+      def root
+        (
+          statement.aka(:first) << (
+            whitespace? << operator.aka(:operator) << whitespace? <<
+              statement.aka(:statement)
+          ).repeat(1).aka(:others).maybe
+        )
+          .aka(:left_operation)
+          .then do |output|
+            if output[:left_operation][:others]
+              output
+            else
+              output[:left_operation][:first]
+            end
+          end
+      end
+    end
+  end
+end

data/lib/code/parser/list.rb

@@ -1,12 +1,14 @@
+# frozen_string_literal: true
+
 class Code
   class Parser
     class List < Language
       def code
-        ::Code::Parser::Code.new.present
+        Code.new.present
       end
 
       def whitespace
-        ::Code::Parser::Whitespace
+        Whitespace
       end
 
       def whitespace?
@@ -32,10 +34,9 @@ class Code
       def root
         (
           opening_square_bracket.ignore << whitespace? <<
-            element.repeat(0, 1) <<
-            (whitespace? << comma << whitespace? << element).repeat <<
+            (whitespace? << element << (whitespace? << comma).maybe).repeat <<
             (whitespace? << closing_square_bracket.ignore).maybe
-        ).aka(:list) | ::Code::Parser::String
+        ).aka(:list) | String
       end
     end
   end

data/lib/code/parser/multiplication.rb

@@ -1,8 +1,10 @@
+# frozen_string_literal: true
+
 class Code
   class Parser
-    class Multiplication < Operation
+    class Multiplication < LeftOperation
       def statement
-        ::Code::Parser::UnaryMinus
+        Negation
       end
 
       def asterisk

data/lib/code/parser/name.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class Code
   class Parser
     class Name < Language
@@ -65,6 +67,18 @@ class Code
         str("&")
       end
 
+      def lesser
+        str("<")
+      end
+
+      def greater
+        str(">")
+      end
+
+      def asterisk
+        str("*")
+      end
+
       def do_keyword
         str("do")
       end
@@ -85,7 +99,8 @@ class Code
         ampersand | equal | pipe | dot | colon | comma | space | newline |
           opening_curly_bracket | closing_curly_bracket | opening_parenthesis |
           closing_parenthesis | opening_square_bracket |
-          closing_square_bracket | single_quote | double_quote
+          closing_square_bracket | single_quote | double_quote | lesser |
+          greater | asterisk
       end
 
       def character
@@ -97,9 +112,9 @@ class Code
       end
 
       def root
-        (do_keyword << separator).absent <<
-          (else_keyword << separator).absent <<
-          (elsif_keyword << separator).absent <<
+        (do_keyword << separator).absent << (
+          else_keyword << separator
+        ).absent << (elsif_keyword << separator).absent <<
           (end_keyword << separator).absent << character.repeat(1)
       end
     end

data/lib/code/parser/negation.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class Code
   class Parser
     class Negation < Language
@@ -18,12 +20,12 @@ class Code
       end
 
       def negation
-        ::Code::Parser::Negation
+        Negation
       end
 
       def root
         (operator.aka(:operator) << negation.aka(:right)).aka(:negation) |
-          ::Code::Parser::Function
+          ChainedCall
       end
     end
   end

data/lib/code/parser/not_keyword.rb

@@ -1,12 +1,14 @@
+# frozen_string_literal: true
+
 class Code
   class Parser
     class NotKeyword < Language
       def not_class
-        ::Code::Parser::NotKeyword
+        NotKeyword
       end
 
       def whitespace
-        ::Code::Parser::Whitespace
+        Whitespace
       end
 
       def not_keyword
@@ -16,7 +18,7 @@ class Code
       def root
         (not_keyword.aka(:operator) << whitespace << not_class.aka(:right)).aka(
           :not
-        ) | ::Code::Parser::Equal
+        ) | Equal
       end
     end
   end

data/lib/code/parser/nothing.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class Code
   class Parser
     class Nothing < Language
@@ -5,17 +7,8 @@ class Code
         str("nothing")
       end
 
-      def null_keyword
-        str("null")
-      end
-
-      def nil_keyword
-        str("nil")
-      end
-
       def root
-        (nothing_keyword | null_keyword | nil_keyword).aka(:nothing) |
-          ::Code::Parser::Group
+        nothing_keyword.aka(:nothing) | Group
       end
     end
   end

data/lib/code/parser/number.rb

@@ -1,8 +1,10 @@
+# frozen_string_literal: true
+
 class Code
   class Parser
     class Number < Language
       def number
-        ::Code::Parser::Number
+        Number
       end
 
       def zero
@@ -147,7 +149,7 @@ class Code
           decimal.aka(:decimal) | base_16_number.aka(:base_16) |
             base_8_number.aka(:base_8) | base_2_number.aka(:base_2) |
             base_10_number.aka(:base_10)
-        ).aka(:number) | ::Code::Parser::Boolean
+        ).aka(:number) | Boolean
       end
     end
   end

data/lib/code/parser/or_keyword.rb

@@ -1,8 +1,10 @@
+# frozen_string_literal: true
+
 class Code
   class Parser
-    class OrKeyword < Operation
+    class OrKeyword < LeftOperation
       def statement
-        ::Code::Parser::NotKeyword
+        NotKeyword
       end
 
       def or_keyword

data/lib/code/parser/or_operator.rb

@@ -1,8 +1,10 @@
+# frozen_string_literal: true
+
 class Code
   class Parser
-    class OrOperator < Operation
+    class OrOperator < LeftOperation
       def statement
-        ::Code::Parser::AndOperator
+        AndOperator
       end
 
       def pipe

data/lib/code/parser/power.rb

@@ -1,20 +1,10 @@
+# frozen_string_literal: true
+
 class Code
   class Parser
-    class Power < Language
-      def power
-        ::Code::Parser::Power
-      end
-
+    class Power < RightOperation
       def statement
-        ::Code::Parser::Negation
-      end
-
-      def whitespace
-        ::Code::Parser::Whitespace
-      end
-
-      def whitespace?
-        whitespace.maybe
+        Function
       end
 
       def asterisk
@@ -24,20 +14,6 @@ class Code
       def operator
         asterisk << asterisk
       end
-
-      def root
-        (
-          statement.aka(:left) <<
-            (
-              whitespace? << operator.aka(:operator) << whitespace? <<
-                power.aka(:right)
-            ).maybe
-        )
-          .aka(:power)
-          .then do |output|
-            output[:power][:right] ? output : output[:power][:left]
-          end
-      end
     end
   end
 end