template-ruby 0.4.0 → 0.5.0

data/lib/code/parser/dictionnary.rb

@@ -1,41 +1,67 @@
 class Code
   class Parser
-    class Dictionnary < Parslet::Parser
-      rule(:list) { ::Code::Parser::List.new }
-      rule(:code) { ::Code::Parser::Code.new.present }
-      rule(:string) { ::Code::Parser::String.new }
-
-      rule(:opening_curly_bracket) { str("{") }
-      rule(:closing_curly_bracket) { str("}") }
-      rule(:colon) { str(":") }
-      rule(:equal) { str("=") }
-      rule(:right_caret) { str(">") }
-      rule(:comma) { str(",") }
-
-      rule(:space) { str(" ") }
-      rule(:newline) { str("\n") }
-      rule(:whitespace) { (space | newline).repeat(1) }
-      rule(:whitespace?) { whitespace.maybe }
-
-      rule(:key_value) do
-        (string.as(:key) >> colon >> whitespace? >> code.as(:value)) |
+    class Dictionnary < Language
+      def code
+        ::Code::Parser::Code.new.present
+      end
+
+      def statement
+        ::Code::Parser::Statement
+      end
+
+      def name
+        ::Code::Parser::Name
+      end
+
+      def whitespace
+        ::Code::Parser::Whitespace
+      end
+
+      def whitespace?
+        whitespace.maybe
+      end
+
+      def opening_curly_bracket
+        str("{")
+      end
+
+      def closing_curly_bracket
+        str("}")
+      end
+
+      def comma
+        str(",")
+      end
+
+      def colon
+        str(":")
+      end
+
+      def equal
+        str("=")
+      end
+
+      def greater
+        str(">")
+      end
+
+      def key_value
+        (name.aka(:name) << colon << code.aka(:value)) |
+          (statement.aka(:statement) << colon << code.aka(:value)) |
           (
-            code.as(:key) >> whitespace? >> equal >> right_caret >>
-              whitespace? >> code.as(:value)
+            statement.aka(:statement) << whitespace? << equal << greater <<
+              code.aka(:value)
           )
       end
 
-      rule(:dictionnary) do
+      def root
         (
-          opening_curly_bracket.ignore >> whitespace?.ignore >>
-            key_value.repeat(0, 1) >>
-            (whitespace? >> comma >> whitespace? >> key_value).repeat >>
-            whitespace?.ignore >> comma.maybe.ignore >> whitespace?.ignore >>
-            closing_curly_bracket.ignore
-        ).as(:dictionnary) | list
+          opening_curly_bracket.ignore << whitespace? <<
+            key_value.repeat(0, 1) <<
+            (whitespace? << comma << whitespace? << key_value).repeat <<
+            (whitespace? << closing_curly_bracket.ignore).maybe
+        ).aka(:dictionnary) | ::Code::Parser::List
       end
-
-      root(:dictionnary)
     end
   end
 end

data/lib/code/parser/equal.rb

@@ -1,42 +1,94 @@
 class Code
   class Parser
-    class Equal < Parslet::Parser
-      rule(:rescue_rule) { ::Code::Parser::Rescue.new }
-      rule(:name) { ::Code::Parser::Name.new }
-
-      rule(:equal) { str("=") }
-      rule(:plus) { str("+") }
-      rule(:minus) { str("-") }
-      rule(:asterisk) { str("*") }
-      rule(:slash) { str("/") }
-      rule(:percent) { str("%") }
-      rule(:left_caret) { str("<") }
-      rule(:right_caret) { str(">") }
-      rule(:ampersand) { str("&") }
-      rule(:pipe) { str("|") }
-      rule(:caret) { str("^") }
-
-      rule(:operator) do
-        equal | (plus >> equal) | (minus >> equal) | (asterisk >> equal) |
-          (slash >> equal) | (percent >> equal) |
-          (left_caret >> left_caret >> equal) |
-          (right_caret >> right_caret >> equal) | (ampersand >> equal) |
-          (pipe >> equal) | (caret >> equal)
-      end
-
-      rule(:space) { str(" ") }
-      rule(:newline) { str("\n") }
-      rule(:whitespace) { (space | newline).repeat(1) }
-      rule(:whitespace?) { whitespace.maybe }
-
-      rule(:equal_rule) do
-        (
-          name.as(:left) >> whitespace? >> operator.as(:operator) >>
-            whitespace? >> rescue_rule.as(:right)
-        ).as(:equal) | rescue_rule
+    class Equal < Language
+      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
+      end
+
+      def equal
+        str("=")
+      end
+
+      def plus
+        str("+")
+      end
+
+      def minus
+        str("-")
       end
 
-      root(:equal_rule)
+      def asterisk
+        str("*")
+      end
+
+      def slash
+        str("/")
+      end
+
+      def percent
+        str("%")
+      end
+
+      def greater
+        str(">")
+      end
+
+      def lesser
+        str("<")
+      end
+
+      def ampersand
+        str("&")
+      end
+
+      def pipe
+        str("|")
+      end
+
+      def caret
+        str("^")
+      end
+
+      def dot
+        str(".")
+      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
+      end
     end
   end
 end

data/lib/code/parser/equality.rb

@@ -1,36 +1,35 @@
 class Code
   class Parser
-    class Equality < Parslet::Parser
-      rule(:while_parser) { ::Code::Parser::While.new }
+    class Equality < Operation
+      def statement
+        ::Code::Parser::Splat
+      end
+
+      def equal
+        str("=")
+      end
 
-      rule(:right_caret) { str(">") }
-      rule(:left_caret) { str("<") }
-      rule(:equal) { str("=") }
-      rule(:exclamation_point) { str("!") }
-      rule(:tilde) { str("~") }
+      def greater
+        str(">")
+      end
 
-      rule(:operator) do
-        (left_caret >> equal >> right_caret) | (equal >> equal >> equal) |
-          (equal >> equal) | (exclamation_point >> equal) | (equal >> tilde) |
-          (exclamation_point >> tilde)
+      def lesser
+        str("<")
       end
 
-      rule(:space) { str(" ") }
-      rule(:newline) { str("\n") }
-      rule(:whitespace) { (space | newline).repeat(1) }
-      rule(:whitespace?) { whitespace.maybe }
+      def exclamation_point
+        str("!")
+      end
 
-      rule(:equality) do
-        (
-          while_parser.as(:first) >>
-            (
-              whitespace? >> operator.as(:operator) >> whitespace? >>
-                while_parser.as(:statement)
-            ).repeat(1).as(:rest)
-        ).as(:equality) | while_parser
+      def tilde
+        str("~")
       end
 
-      root(:equality)
+      def operator
+        (equal << equal << equal) | (equal << equal) |
+          (lesser << equal << greater) | (exclamation_point << equal) |
+          (equal << tilde) | (tilde << equal) | (exclamation_point << tilde)
+      end
     end
   end
 end

data/lib/code/parser/equality_lower.rb

@@ -0,0 +1,9 @@
+class Code
+  class Parser
+    class EqualityLower < Equality
+      def statement
+        ::Code::Parser::Greater
+      end
+    end
+  end
+end

data/lib/code/parser/function.rb

@@ -1,60 +1,85 @@
 class Code
   class Parser
-    class Function < Parslet::Parser
-      rule(:call) { ::Code::Parser::Call.new }
-      rule(:code_present) { ::Code::Parser::Code.new.present }
-      rule(:code) { ::Code::Parser::Code.new }
-      rule(:name) { ::Code::Parser::Name.new }
+    class Function < Language
+      def name
+        ::Code::Parser::Name
+      end
+
+      def code
+        ::Code::Parser::Code
+      end
 
-      rule(:opening_parenthesis) { str("(") }
-      rule(:closing_parenthesis) { str(")") }
-      rule(:equal) { str("=") }
-      rule(:right_caret) { str(">") }
-      rule(:opening_curly_bracket) { str("{") }
-      rule(:closing_curly_bracket) { str("}") }
-      rule(:comma) { str(",") }
-      rule(:colon) { str(":") }
-      rule(:asterisk) { str("*") }
-      rule(:ampersand) { str("&") }
+      def code_present
+        ::Code::Parser::Code.new.present
+      end
 
-      rule(:space) { str(" ") }
-      rule(:newline) { str("\n") }
-      rule(:whitespace) { (space | newline).repeat(1) }
-      rule(:whitespace?) { whitespace.maybe }
+      def whitespace
+        ::Code::Parser::Whitespace
+      end
 
-      rule(:keyword_argument) do
-        name >> whitespace? >> colon >> code_present.as(:default).maybe
+      def whitespace?
+        whitespace.maybe
       end
 
-      rule(:regular_argument) do
-        ampersand.as(:block).maybe >>
-          (asterisk >> asterisk).as(:keyword_splat).maybe >>
-          asterisk.as(:splat).maybe >> name >>
-          (
-            whitespace? >> equal >> whitespace? >> code_present.as(:default)
-          ).maybe
+      def opening_parenthesis
+        str("(")
       end
 
-      rule(:argument) do
-        keyword_argument.as(:keyword) | regular_argument.as(:regular)
+      def closing_parenthesis
+        str(")")
       end
 
-      rule(:arguments) do
-        argument.repeat(1, 1) >>
-          (whitespace? >> comma >> whitespace? >> argument).repeat
+      def colon
+        str(":")
       end
 
-      rule(:function) do
-        (
-          opening_parenthesis >> whitespace? >>
-            arguments.as(:arguments).maybe >> whitespace? >>
-            closing_parenthesis >> whitespace? >> equal >> right_caret >>
-            whitespace? >> opening_curly_bracket >> code.as(:body) >>
-            closing_curly_bracket
-        ).as(:function) | call
+      def comma
+        str(",")
+      end
+
+      def equal
+        str("=")
+      end
+
+      def greater
+        str(">")
+      end
+
+      def opening_curly_bracket
+        str("{")
       end
 
-      root(:function)
+      def closing_curly_bracket
+        str("}")
+      end
+
+      def keyword_parameter
+        name.aka(:name) << whitespace? << colon.aka(:keyword) <<
+          code_present.aka(:default).maybe
+      end
+
+      def regular_parameter
+        name.aka(:name) << whitespace? <<
+          (equal << whitespace? << code_present.aka(:default)).maybe
+      end
+
+      def parameter
+        keyword_parameter | regular_parameter
+      end
+
+      def parameters
+        opening_parenthesis.ignore << whitespace? << parameter.repeat(0, 1) <<
+          (whitespace? << comma << whitespace? << parameter).repeat <<
+          whitespace? << closing_parenthesis.ignore.maybe
+      end
+
+      def root
+        (
+          parameters.aka(:parameters) << whitespace? << equal << greater <<
+            whitespace? << opening_curly_bracket << code.aka(:body) <<
+            closing_curly_bracket.maybe
+        ).aka(:function) | ::Code::Parser::ChainedCall
+      end
     end
   end
 end

data/lib/code/parser/greater.rb

@@ -0,0 +1,25 @@
+class Code
+  class Parser
+    class Greater < Operation
+      def statement
+        ::Code::Parser::BitwiseOr
+      end
+
+      def greater
+        str(">")
+      end
+
+      def lesser
+        str("<")
+      end
+
+      def equal
+        str("=")
+      end
+
+      def operator
+        (greater << equal) | (lesser << equal) | greater | lesser
+      end
+    end
+  end
+end

data/lib/code/parser/group.rb

@@ -1,17 +1,22 @@
 class Code
   class Parser
-    class Group < Parslet::Parser
-      rule(:name) { ::Code::Parser::Name.new }
-      rule(:code) { ::Code::Parser::Code.new.present }
+    class Group < Language
+      def code
+        ::Code::Parser::Code
+      end
 
-      rule(:opening_parenthesis) { str("(") }
-      rule(:closing_parenthesis) { str(")") }
+      def opening_parenthesis
+        str("(")
+      end
 
-      rule(:group) do
-        (opening_parenthesis >> code >> closing_parenthesis).as(:group) | name
+      def closing_parenthesis
+        str(")")
       end
 
-      root(:group)
+      def root
+        (opening_parenthesis << code << closing_parenthesis.maybe).aka(:group) |
+          ::Code::Parser::Call
+      end
     end
   end
 end

data/lib/code/parser/if.rb

@@ -1,33 +1,63 @@
 class Code
   class Parser
-    class If < Parslet::Parser
-      rule(:if_modifier) { ::Code::Parser::IfModifier.new }
-      rule(:code) { ::Code::Parser::Code.new.present }
+    class If < Language
+      def statement
+        ::Code::Parser::IfModifier
+      end
+
+      def if_class
+        ::Code::Parser::If
+      end
+
+      def whitespace
+        ::Code::Parser::Whitespace
+      end
+
+      def code
+        ::Code::Parser::Code
+      end
+
+      def whitespace?
+        whitespace.maybe
+      end
 
-      rule(:if_keyword) { str("if") }
-      rule(:else_keyword) { str("else") }
-      rule(:unless_keyword) { str("unless") }
-      rule(:end_keyword) { str("end") }
+      def if_keyword
+        str("if")
+      end
 
-      rule(:space) { str(" ") }
-      rule(:newline) { str("\n") }
-      rule(:whitespace) { (space | newline).repeat(1) }
+      def unless_keyword
+        str("unless")
+      end
 
-      rule(:if_rule) do
+      def elsif_keyword
+        str("elsif")
+      end
+
+      def else_keyword
+        str("else")
+      end
+
+      def end_keyword
+        str("end")
+      end
+
+      def root
         (
-          (if_keyword | unless_keyword).as(:if_operator) >> whitespace >>
-            if_modifier.as(:if_statement) >> code.as(:if_body).maybe >>
+          (if_keyword | unless_keyword).aka(:first_operator) << whitespace <<
+            statement.aka(:first_statement) << code.aka(:first_body) <<
             (
-              else_keyword >>
+              (
+                elsif_keyword.aka(:operator) << whitespace <<
+                  statement.aka(:statement) << code.aka(:body)
+              ) |
                 (
-                  whitespace >> (if_keyword | unless_keyword).as(:operator) >>
-                    whitespace >> if_modifier.as(:statement)
-                ).maybe >> code.as(:body).maybe
-            ).repeat(1).as(:elses).maybe >> end_keyword
-        ).as(:if) | if_modifier
+                  else_keyword << whitespace <<
+                    (if_keyword | unless_keyword).aka(:operator) <<
+                    whitespace << statement.aka(:statement) << code.aka(:body)
+                ) | (else_keyword.aka(:operator) << code.aka(:body))
+            ).repeat(1).aka(:elses).maybe << end_keyword.maybe
+        ).aka(:if) | statement
       end
-
-      root(:if_rule)
     end
   end
 end

data/lib/code/parser/if_modifier.rb

@@ -1,28 +1,55 @@
 class Code
   class Parser
-    class IfModifier < Parslet::Parser
-      rule(:or_keyword) { ::Code::Parser::OrKeyword.new }
+    class IfModifier < Language
+      def statement
+        ::Code::Parser::OrKeyword
+      end
 
-      rule(:if_keyword) { str("if") }
-      rule(:unless_keyword) { str("unless") }
-      rule(:while_keyword) { str("while") }
-      rule(:until_keyword) { str("until") }
+      def if_modifier
+        ::Code::Parser::IfModifier
+      end
 
-      rule(:operator) do
-        if_keyword | unless_keyword | while_keyword | until_keyword
+      def whitespace
+        ::Code::Parser::Whitespace.new.without_newline
+      end
+
+      def whitespace?
+        whitespace.maybe
       end
 
-      rule(:space) { str(" ") }
-      rule(:whitespace) { space.repeat(1) }
+      def if_keyword
+        str("if")
+      end
 
-      rule(:if_modifier) do
-        (
-          or_keyword.as(:left) >> whitespace >> operator.as(:operator) >>
-            whitespace >> if_modifier.as(:right)
-        ).as(:if_modifier) | or_keyword
+      def unless_keyword
+        str("unless")
+      end
+
+      def while_keyword
+        str("while")
+      end
+
+      def until_keyword
+        str("until")
+      end
+
+      def operator
+        if_keyword | unless_keyword | while_keyword | until_keyword
       end
 
-      root(:if_modifier)
+      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