code-ruby 0.2.4

data/lib/code/parser/addition.rb

@@ -0,0 +1,29 @@
+class Code
+  class Parser
+    class Addition < Parslet::Parser
+      rule(:multiplication) { ::Code::Parser::Multiplication.new }
+
+      rule(:plus) { str("+") }
+      rule(:minus) { str("-") }
+
+      rule(:operator) { plus | minus }
+
+      rule(:space) { str(" ") }
+      rule(:newline) { str("\n") }
+      rule(:whitespace) { (space | newline).repeat(1) }
+      rule(:whitespace?) { whitespace.maybe }
+
+      rule(:addition) do
+        (
+          multiplication.as(:first) >>
+            (
+              whitespace? >> operator.as(:operator) >> whitespace? >>
+                multiplication.as(:statement)
+            ).repeat(1).as(:rest)
+        ).as(:addition) | multiplication
+      end
+
+      root(:addition)
+    end
+  end
+end

data/lib/code/parser/and_operator.rb

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

data/lib/code/parser/bitwise_and.rb

@@ -0,0 +1,28 @@
+class Code
+  class Parser
+    class BitwiseAnd < Parslet::Parser
+      rule(:shift) { ::Code::Parser::Shift.new }
+
+      rule(:ampersand) { str("&") }
+
+      rule(:operator) { ampersand }
+
+      rule(:space) { str(" ") }
+      rule(:newline) { str("\n") }
+      rule(:whitespace) { (space | newline).repeat(1) }
+      rule(:whitespace?) { whitespace.maybe }
+
+      rule(:bitwise_and) do
+        (
+          shift.as(:first) >>
+            (
+              whitespace? >> operator.as(:operator) >> whitespace? >>
+                shift.as(:statement)
+            ).repeat(1).as(:rest)
+        ).as(:bitwise_and) | shift
+      end
+
+      root(:bitwise_and)
+    end
+  end
+end

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/boolean.rb

@@ -0,0 +1,14 @@
+class Code
+  class Parser
+    class Boolean < Parslet::Parser
+      rule(:nothing) { ::Code::Parser::Nothing.new }
+
+      rule(:true_keyword) { str("true") }
+      rule(:false_keyword) { str("false") }
+
+      rule(:boolean) { (true_keyword | false_keyword).as(:boolean) | nothing }
+
+      root(:boolean)
+    end
+  end
+end

data/lib/code/parser/call.rb

@@ -0,0 +1,90 @@
+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(: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
+end

data/lib/code/parser/code.rb

@@ -0,0 +1,19 @@
+class Code
+  class Parser
+    class Code < Parslet::Parser
+      rule(:statement) { ::Code::Parser::Statement.new }
+
+      rule(:space) { str(" ") }
+      rule(:newline) { str("\n") }
+      rule(:whitespace) { (space | newline).repeat(1) }
+      rule(:whitespace?) { whitespace.maybe }
+
+      rule(:code) do
+        (whitespace?.ignore >> statement >> whitespace?.ignore).repeat(1) |
+          whitespace?.ignore
+      end
+
+      root(:code)
+    end
+  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/dictionnary.rb

@@ -0,0 +1,41 @@
+class Code
+  class Parser
+    class Dictionnary < Parslet::Parser
+      rule(:list) { ::Code::Parser::List.new }
+      rule(:code) { ::Code::Parser::Code.new }
+      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)) |
+          (
+            code.as(:key) >> whitespace? >> equal >> right_caret >>
+              whitespace? >> code.as(:value)
+          )
+      end
+
+      rule(:dictionnary) do
+        (
+          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
+      end
+
+      root(:dictionnary)
+    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/list.rb

@@ -0,0 +1,29 @@
+class Code
+  class Parser
+    class List < Parslet::Parser
+      rule(:string) { ::Code::Parser::String.new }
+      rule(:code) { ::Code::Parser::Code.new }
+
+      rule(:opening_square_bracket) { str("[") }
+      rule(:closing_square_bracket) { str("]") }
+      rule(:comma) { str(",") }
+
+      rule(:space) { str(" ") }
+      rule(:newline) { str("\n") }
+      rule(:whitespace) { (space | newline).repeat(1) }
+      rule(:whitespace?) { whitespace.maybe }
+
+      rule(:list) do
+        (
+          opening_square_bracket.ignore >> whitespace?.ignore >>
+            code.as(:code).repeat(0, 1) >>
+            (whitespace? >> comma >> whitespace? >> code.as(:code)).repeat >>
+            whitespace?.ignore >> comma.maybe.ignore >> whitespace?.ignore >>
+            closing_square_bracket.ignore
+        ).as(:list) | string
+      end
+
+      root(:list)
+    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