template-ruby 0.1.0 → 0.2.0

data/lib/code/parser/bitwise_or.rb

@@ -0,0 +1,29 @@
+class Code
+  class Parser
+    class BitwiseOr < Parslet::Parser
+      rule(:bitwise_and) { ::Code::Parser::BitwiseAnd.new }
+
+      rule(:pipe) { str("|") }
+      rule(:caret) { str("^") }
+
+      rule(:operator) { pipe | caret }
+
+      rule(:space) { str(" ") }
+      rule(:newline) { str("\n") }
+      rule(:whitespace) { (space | newline).repeat(1) }
+      rule(:whitespace?) { whitespace.maybe }
+
+      rule(:bitwise_or) do
+        (
+          bitwise_and.as(:first) >>
+            (
+              whitespace? >> operator.as(:operator) >> whitespace? >>
+                bitwise_and.as(:statement)
+            ).repeat(1).as(:rest)
+        ).as(:bitwise_or) | bitwise_and
+      end
+
+      root(:bitwise_or)
+    end
+  end
+end

data/lib/code/parser/call.rb

@@ -2,14 +2,88 @@ class Code
   class Parser
     class Call < Parslet::Parser
       rule(:dictionnary) { ::Code::Parser::Dictionnary.new }
+      rule(:code) { ::Code::Parser::Code.new }
+      rule(:name) { ::Code::Parser::Name.new }
+      rule(:function_arguments) { ::Code::Parser::Function.new.arguments }
 
       rule(:dot) { str(".") }
+      rule(:opening_parenthesis) { str("(") }
+      rule(:closing_parenthesis) { str(")") }
+      rule(:opening_curly_bracket) { str("{") }
+      rule(:closing_curly_bracket) { str("}") }
+      rule(:comma) { str(",") }
+      rule(:colon) { str(":") }
+      rule(:ampersand) { str("&") }
+      rule(:asterisk) { str("*") }
+      rule(:pipe) { str("|") }
+      rule(:do_keyword) { str("do") }
+      rule(:end_keyword) { str("end") }
 
-      rule(:call) do
-        (dictionnary.as(:left) >> dot >> call.as(:right)).as(:call) |
-          dictionnary
+      rule(:space) { str(" ") }
+      rule(:newline) { str("\n") }
+      rule(:whitespace) { (space | newline).repeat(1) }
+      rule(:whitespace?) { whitespace.maybe }
+
+      rule(:keyword_argument) do
+        name >> whitespace? >> colon >> whitespace? >> code.as(:value)
+      end
+
+      rule(:regular_argument) do
+        ampersand.as(:block).maybe >>
+          (asterisk >> asterisk).as(:keyword_splat).maybe >>
+          asterisk.as(:splat).maybe >> code.as(:value)
+      end
+
+      rule(:argument) do
+        keyword_argument.as(:keyword) | regular_argument.as(:regular)
+      end
+
+      rule(:arguments) do
+        argument.repeat(1, 1) >>
+          (whitespace? >> comma >> whitespace? >> argument).repeat
+      end
+
+      rule(:single_call) do
+        dictionnary.as(:left) >>
+          (
+            opening_parenthesis >> whitespace? >>
+              arguments.as(:arguments).maybe >> whitespace? >>
+              closing_parenthesis
+          ) >> block.as(:block).maybe
       end
 
+      rule(:chained_single_call) do
+        dot >> name >>
+          (
+            opening_parenthesis >> whitespace? >>
+              arguments.as(:arguments).maybe >> whitespace? >>
+              closing_parenthesis
+          ).maybe >> block.as(:block).maybe
+      end
+
+      rule(:chained_call) do
+        dictionnary.as(:left) >> chained_single_call.repeat(1).as(:right)
+      end
+
+      rule(:block_arguments) do
+        pipe >> whitespace? >> function_arguments >> whitespace? >> pipe
+      end
+
+      rule(:block) do
+        (
+          whitespace >> do_keyword >> whitespace >>
+            block_arguments.as(:arguments).maybe >> code.as(:body) >>
+            end_keyword
+        ) |
+          (
+            whitespace? >> opening_curly_bracket >> whitespace >>
+              block_arguments.as(:arguments).maybe >> code.as(:body) >>
+              closing_curly_bracket
+          )
+      end
+
+      rule(:call) { (single_call | chained_call).as(:call) | dictionnary }
+
       root(:call)
     end
   end

data/lib/code/parser/defined.rb

@@ -0,0 +1,20 @@
+class Code
+  class Parser
+    class Defined < Parslet::Parser
+      rule(:equal) { ::Code::Parser::Equal.new }
+      rule(:name) { ::Code::Parser::Name.new }
+
+      rule(:defined_keyword) { str("defined?") }
+      rule(:opening_parenthesis) { str("(") }
+      rule(:closing_parenthesis) { str(")") }
+
+      rule(:defined) do
+        (
+          defined_keyword >> opening_parenthesis >> name >> closing_parenthesis
+        ).as(:defined) | equal
+      end
+
+      root(:defined)
+    end
+  end
+end

data/lib/code/parser/equal.rb

@@ -0,0 +1,42 @@
+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
+      end
+
+      root(:equal_rule)
+    end
+  end
+end

data/lib/code/parser/equality.rb

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

data/lib/code/parser/function.rb

@@ -0,0 +1,57 @@
+class Code
+  class Parser
+    class Function < Parslet::Parser
+      rule(:call) { ::Code::Parser::Call.new }
+      rule(:code) { ::Code::Parser::Code.new }
+      rule(:name) { ::Code::Parser::Name.new }
+
+      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("&") }
+
+      rule(:space) { str(" ") }
+      rule(:newline) { str("\n") }
+      rule(:whitespace) { (space | newline).repeat(1) }
+      rule(:whitespace?) { whitespace.maybe }
+
+      rule(:keyword_argument) do
+        name >> whitespace? >> colon >> (whitespace? >> code.as(:default)).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.as(:default)).maybe
+      end
+
+      rule(:argument) do
+        keyword_argument.as(:keyword) | regular_argument.as(:regular)
+      end
+
+      rule(:arguments) do
+        argument.repeat(1, 1) >>
+          (whitespace? >> comma >> whitespace? >> argument).repeat
+      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
+      end
+
+      root(:function)
+    end
+  end
+end

data/lib/code/parser/greater_than.rb

@@ -0,0 +1,33 @@
+class Code
+  class Parser
+    class GreaterThan < Parslet::Parser
+      rule(:bitwise_or) { ::Code::Parser::BitwiseOr.new }
+
+      rule(:right_caret) { str(">") }
+      rule(:left_caret) { str("<") }
+      rule(:equal) { str("=") }
+
+      rule(:operator) do
+        (right_caret >> equal) | (left_caret >> equal) | right_caret |
+          left_caret
+      end
+
+      rule(:space) { str(" ") }
+      rule(:newline) { str("\n") }
+      rule(:whitespace) { (space | newline).repeat(1) }
+      rule(:whitespace?) { whitespace.maybe }
+
+      rule(:greater_than) do
+        (
+          bitwise_or.as(:first) >>
+            (
+              whitespace? >> operator.as(:operator) >> whitespace? >>
+                bitwise_or.as(:statement)
+            ).repeat(1).as(:rest)
+        ).as(:greater_than) | bitwise_or
+      end
+
+      root(:greater_than)
+    end
+  end
+end

data/lib/code/parser/group.rb

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

data/lib/code/parser/if.rb

@@ -0,0 +1,33 @@
+class Code
+  class Parser
+    class If < Parslet::Parser
+      rule(:if_modifier) { ::Code::Parser::IfModifier.new }
+      rule(:code) { ::Code::Parser::Code.new }
+
+      rule(:if_keyword) { str("if") }
+      rule(:else_keyword) { str("else") }
+      rule(:unless_keyword) { str("unless") }
+      rule(:end_keyword) { str("end") }
+
+      rule(:space) { str(" ") }
+      rule(:newline) { str("\n") }
+      rule(:whitespace) { (space | newline).repeat(1) }
+
+      rule(:if_rule) do
+        (
+          (if_keyword | unless_keyword).as(:if_operator) >> whitespace >>
+            if_modifier.as(:if_statement) >> code.as(:if_body) >>
+            (
+              else_keyword >>
+                (
+                  whitespace >> (if_keyword | unless_keyword).as(:operator) >>
+                    whitespace >> if_modifier.as(:statement)
+                ).maybe >> code.as(:body)
+            ).repeat(1).as(:elses).maybe >> end_keyword
+        ).as(:if) | if_modifier
+      end
+
+      root(:if_rule)
+    end
+  end
+end

data/lib/code/parser/if_modifier.rb

@@ -0,0 +1,28 @@
+class Code
+  class Parser
+    class IfModifier < Parslet::Parser
+      rule(:or_keyword) { ::Code::Parser::OrKeyword.new }
+
+      rule(:if_keyword) { str("if") }
+      rule(:unless_keyword) { str("unless") }
+      rule(:while_keyword) { str("while") }
+      rule(:until_keyword) { str("until") }
+
+      rule(:operator) do
+        if_keyword | unless_keyword | while_keyword | until_keyword
+      end
+
+      rule(:space) { str(" ") }
+      rule(:whitespace) { space.repeat(1) }
+
+      rule(:if_modifier) do
+        (
+          or_keyword.as(:left) >> whitespace >> operator.as(:operator) >>
+            whitespace >> if_modifier.as(:right)
+        ).as(:if_modifier) | or_keyword
+      end
+
+      root(:if_modifier)
+    end
+  end
+end

data/lib/code/parser/multiplication.rb

@@ -0,0 +1,30 @@
+class Code
+  class Parser
+    class Multiplication < Parslet::Parser
+      rule(:unary_minus) { ::Code::Parser::UnaryMinus.new }
+
+      rule(:asterisk) { str("*") }
+      rule(:slash) { str("/") }
+      rule(:percent) { str("%") }
+
+      rule(:operator) { asterisk | slash | percent }
+
+      rule(:space) { str(" ") }
+      rule(:newline) { str("\n") }
+      rule(:whitespace) { (space | newline).repeat(1) }
+      rule(:whitespace?) { whitespace.maybe }
+
+      rule(:multiplication) do
+        (
+          unary_minus.as(:first) >>
+            (
+              whitespace? >> operator.as(:operator) >> whitespace? >>
+                unary_minus.as(:statement)
+            ).repeat(1).as(:rest)
+        ).as(:multiplication) | unary_minus
+      end
+
+      root(:multiplication)
+    end
+  end
+end

data/lib/code/parser/name.rb

@@ -12,9 +12,36 @@ class Code
       rule(:closing_curly_bracket) { str("}") }
       rule(:opening_square_bracket) { str("[") }
       rule(:closing_square_bracket) { str("]") }
+      rule(:opening_parenthesis) { str("(") }
+      rule(:closing_parenthesis) { str(")") }
       rule(:equal) { str("=") }
       rule(:left_caret) { str("<") }
       rule(:right_caret) { str(">") }
+      rule(:tilde) { str("~") }
+      rule(:pipe) { str("|") }
+      rule(:ampersand) { str("&") }
+      rule(:asterisk) { str("*") }
+      rule(:slash) { str("/") }
+      rule(:antislash) { str("\\") }
+      rule(:percent) { str("%") }
+      rule(:plus) { str("+") }
+      rule(:minus) { str("-") }
+      rule(:equal) { str("=") }
+
+      rule(:exclamation_point) { str("!") }
+      rule(:question_mark) { str("?") }
+
+      rule(:rescue_keyword) { str("rescue") }
+      rule(:defined_keyword) { str("defined?") }
+      rule(:not_keyword) { str("not") }
+      rule(:or_keyword) { str("or") }
+      rule(:and_keyword) { str("and") }
+      rule(:if_keyword) { str("if") }
+      rule(:else_keyword) { str("else") }
+      rule(:unless_keyword) { str("unless") }
+      rule(:until_keyword) { str("until") }
+      rule(:while_keyword) { str("while") }
+      rule(:end_keyword) { str("end") }
 
       rule(:zero) { str("0") }
       rule(:one) { str("1") }
@@ -32,18 +59,31 @@ class Code
       end
 
       rule(:name_character) do
-        space.absent? >> newline.absent? >> comma.absent? >> colon.absent? >>
-          dot.absent? >> single_quote.absent? >> double_quote.absent? >>
+        opening_parenthesis.absent? >> closing_parenthesis.absent? >>
+          exclamation_point.absent? >> question_mark.absent? >> tilde.absent? >>
+          pipe.absent? >> ampersand.absent? >> asterisk.absent? >>
+          slash.absent? >> antislash.absent? >> percent.absent? >>
+          plus.absent? >> minus.absent? >> equal.absent? >> space.absent? >>
+          newline.absent? >> comma.absent? >> colon.absent? >> dot.absent? >>
+          single_quote.absent? >> double_quote.absent? >>
           opening_curly_bracket.absent? >> closing_curly_bracket.absent? >>
           opening_square_bracket.absent? >> closing_square_bracket.absent? >>
           equal.absent? >> left_caret.absent? >> right_caret.absent? >> any
       end
 
       rule(:name) do
-        (digit.absent? >> name_character >> name_character.repeat).as(:name)
+        rescue_keyword.absent? >> defined_keyword.absent? >>
+          not_keyword.absent? >> or_keyword.absent? >> and_keyword.absent? >>
+          if_keyword.absent? >> else_keyword.absent? >>
+          unless_keyword.absent? >> until_keyword.absent? >>
+          while_keyword.absent? >> digit.absent? >> end_keyword.absent? >>
+          name_character >> name_character.repeat >> question_mark.maybe >>
+          exclamation_point.maybe
       end
 
-      root(:name)
+      rule(:name_rule) { name.as(:name) }
+
+      root(:name_rule)
     end
   end
 end

data/lib/code/parser/negation.rb

@@ -0,0 +1,19 @@
+class Code
+  class Parser
+    class Negation < Parslet::Parser
+      rule(:function) { ::Code::Parser::Function.new }
+
+      rule(:exclamation_point) { str("!") }
+      rule(:plus) { str("+") }
+
+      rule(:operator) { exclamation_point | plus }
+
+      rule(:negation) do
+        (operator.as(:operator) >> negation.as(:statement)).as(:negation) |
+          function
+      end
+
+      root(:negation)
+    end
+  end
+end

data/lib/code/parser/not_keyword.rb

@@ -0,0 +1,21 @@
+class Code
+  class Parser
+    class NotKeyword < Parslet::Parser
+      rule(:defined) { ::Code::Parser::Defined.new }
+
+      rule(:not_keyword) { str("not") }
+
+      rule(:operator) { not_keyword }
+
+      rule(:space) { str(" ") }
+      rule(:newline) { str("\n") }
+      rule(:whitespace) { (space | newline).repeat(1) }
+
+      rule(:not_rule) do
+        (not_keyword >> whitespace >> not_rule).as(:not_keyword) | defined
+      end
+
+      root(:not_rule)
+    end
+  end
+end

data/lib/code/parser/nothing.rb

@@ -1,14 +1,14 @@
 class Code
   class Parser
     class Nothing < Parslet::Parser
-      rule(:name) { ::Code::Parser::Name.new }
+      rule(:group) { ::Code::Parser::Group.new }
 
       rule(:nothing_keyword) { str("nothing") }
       rule(:null_keyword) { str("null") }
       rule(:nil_keyword) { str("nil") }
 
       rule(:nothing) do
-        (nothing_keyword | null_keyword | nil_keyword).as(:nothing) | name
+        (nothing_keyword | null_keyword | nil_keyword).as(:nothing) | group
       end
 
       root(:nothing)

data/lib/code/parser/or_keyword.rb

@@ -0,0 +1,29 @@
+class Code
+  class Parser
+    class OrKeyword < Parslet::Parser
+      rule(:not_keyword) { ::Code::Parser::NotKeyword.new }
+
+      rule(:or_keyword) { str("or") }
+      rule(:and_keyword) { str("and") }
+
+      rule(:operator) { or_keyword | and_keyword }
+
+      rule(:space) { str(" ") }
+      rule(:newline) { str("\n") }
+      rule(:whitespace) { (space | newline).repeat(1) }
+      rule(:whitespace?) { whitespace.maybe }
+
+      rule(:or_rule) do
+        (
+          not_keyword.as(:first) >>
+            (
+              whitespace? >> operator.as(:operator) >> whitespace? >>
+                not_keyword.as(:statement)
+            ).repeat(1).as(:rest)
+        ).as(:or_keyword) | not_keyword
+      end
+
+      root(:or_rule)
+    end
+  end
+end

data/lib/code/parser/or_operator.rb

@@ -0,0 +1,28 @@
+class Code
+  class Parser
+    class OrOperator < Parslet::Parser
+      rule(:and_operator) { ::Code::Parser::AndOperator.new }
+
+      rule(:pipe) { str("|") }
+
+      rule(:operator) { pipe >> pipe }
+
+      rule(:space) { str(" ") }
+      rule(:newline) { str("\n") }
+      rule(:whitespace) { (space | newline).repeat(1) }
+      rule(:whitespace?) { whitespace.maybe }
+
+      rule(:or_operator) do
+        (
+          and_operator.as(:first) >>
+            (
+              whitespace? >> operator.as(:operator) >> whitespace? >>
+                and_operator.as(:statement)
+            ).repeat(1).as(:rest)
+        ).as(:or_operator) | and_operator
+      end
+
+      root(:or_operator)
+    end
+  end
+end

data/lib/code/parser/power.rb

@@ -0,0 +1,25 @@
+class Code
+  class Parser
+    class Power < Parslet::Parser
+      rule(:negation) { ::Code::Parser::Negation.new }
+
+      rule(:asterisk) { str("*") }
+
+      rule(:operator) { asterisk >> asterisk }
+
+      rule(:space) { str(" ") }
+      rule(:newline) { str("\n") }
+      rule(:whitespace) { (space | newline).repeat(1) }
+      rule(:whitespace?) { whitespace.maybe }
+
+      rule(:power) do
+        (
+          negation.as(:left) >> whitespace? >> operator >> whitespace? >>
+            power.as(:right)
+        ).as(:power) | negation
+      end
+
+      root(:power)
+    end
+  end
+end

data/lib/code/parser/range.rb

@@ -0,0 +1,25 @@
+class Code
+  class Parser
+    class Range < Parslet::Parser
+      rule(:or_operator) { ::Code::Parser::OrOperator.new }
+
+      rule(:dot) { str(".") }
+
+      rule(:operator) { dot >> dot >> dot | dot >> dot }
+
+      rule(:space) { str(" ") }
+      rule(:newline) { str("\n") }
+      rule(:whitespace) { (space | newline).repeat(1) }
+      rule(:whitespace?) { whitespace.maybe }
+
+      rule(:range) do
+        (
+          or_operator.as(:left) >> whitespace? >> operator.as(:operator) >>
+            whitespace? >> range.as(:right)
+        ).as(:range) | or_operator
+      end
+
+      root(:range)
+    end
+  end
+end