code-ruby 0.4.0 → 0.5.0

data/lib/code/parser/or_keyword.rb

@@ -1,29 +1,21 @@
 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 }
+    class OrKeyword < Operation
+      def statement
+        ::Code::Parser::NotKeyword
+      end
 
-      rule(:space) { str(" ") }
-      rule(:newline) { str("\n") }
-      rule(:whitespace) { (space | newline).repeat(1) }
-      rule(:whitespace?) { whitespace.maybe }
+      def or_keyword
+        str("or")
+      end
 
-      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
+      def and_keyword
+        str("and")
       end
 
-      root(:or_rule)
+      def operator
+        or_keyword | and_keyword
+      end
     end
   end
 end

data/lib/code/parser/or_operator.rb

@@ -1,28 +1,17 @@
 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 }
+    class OrOperator < Operation
+      def statement
+        ::Code::Parser::AndOperator
+      end
 
-      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
+      def pipe
+        str("|")
       end
 
-      root(:or_operator)
+      def operator
+        pipe << pipe
+      end
     end
   end
 end

data/lib/code/parser/power.rb

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

data/lib/code/parser/range.rb

@@ -1,25 +1,17 @@
 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 }
+    class Range < Operation
+      def statement
+        ::Code::Parser::OrOperator
+      end
 
-      rule(:range) do
-        (
-          or_operator.as(:left) >> whitespace? >> operator.as(:operator) >>
-            whitespace? >> range.as(:right)
-        ).as(:range) | or_operator
+      def dot
+        str(".")
       end
 
-      root(:range)
+      def operator
+        (dot << dot << dot) | (dot << dot)
+      end
     end
   end
 end

data/lib/code/parser/rescue.rb

@@ -1,23 +1,39 @@
 class Code
   class Parser
-    class Rescue < Parslet::Parser
-      rule(:ternary) { ::Code::Parser::Ternary.new }
+    class Rescue < Language
+      def statement
+        ::Code::Parser::Ternary
+      end
 
-      rule(:rescue_keyword) { str("rescue") }
+      def rescue_class
+        ::Code::Parser::Rescue
+      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(:rescue) do
-        (
-          ternary.as(:left) >> whitespace? >> rescue_keyword >> whitespace? >>
-            ternary.as(:right)
-        ).as(:rescue) | ternary
+      def whitespace?
+        whitespace.maybe
       end
 
-      root(:rescue)
+      def rescue_keyword
+        str("rescue")
+      end
+
+      def root
+        (
+          statement.aka(:left) <<
+            (
+              whitespace? << rescue_keyword << whitespace? <<
+                rescue_class.aka(:right)
+            ).maybe
+        )
+          .aka(:rescue)
+          .then do |output|
+            output[:rescue][:right] ? output : output[:rescue][:left]
+          end
+      end
     end
   end
 end

data/lib/code/parser/shift.rb

@@ -1,31 +1,21 @@
 class Code
   class Parser
-    class Shift < Parslet::Parser
-      rule(:addition) { ::Code::Parser::Addition.new }
-
-      rule(:right_caret) { str(">") }
-      rule(:left_caret) { str("<") }
-
-      rule(:operator) do
-        (left_caret >> left_caret) | (right_caret >> right_caret)
+    class Shift < Operation
+      def statement
+        ::Code::Parser::Addition
       end
 
-      rule(:space) { str(" ") }
-      rule(:newline) { str("\n") }
-      rule(:whitespace) { (space | newline).repeat(1) }
-      rule(:whitespace?) { whitespace.maybe }
+      def greater
+        str(">")
+      end
 
-      rule(:shift) do
-        (
-          addition.as(:first) >>
-            (
-              whitespace? >> operator.as(:operator) >> whitespace? >>
-                addition.as(:statement)
-            ).repeat(1).as(:rest)
-        ).as(:shift) | addition
+      def lesser
+        str("<")
       end
 
-      root(:shift)
+      def operator
+        (greater << greater) | (lesser << lesser)
+      end
     end
   end
 end

data/lib/code/parser/splat.rb

@@ -0,0 +1,31 @@
+class Code
+  class Parser
+    class Splat < Language
+      def statement
+        ::Code::Parser::Class
+      end
+
+      def splat
+        ::Code::Parser::Splat
+      end
+
+      def whitespace
+        ::Code::Parser::Whitespace
+      end
+
+      def whitespace?
+        whitespace.maybe
+      end
+
+      def ampersand
+        str("&")
+      end
+
+      def root
+        (ampersand.aka(:operator) << whitespace? << splat.aka(:right)).aka(
+          :splat
+        ) | statement
+      end
+    end
+  end
+end

data/lib/code/parser/statement.rb

@@ -1,8 +1,9 @@
 class Code
   class Parser
-    class Statement < Parslet::Parser
-      rule(:statement) { ::Code::Parser::Equality.new }
-      root(:statement)
+    class Statement < Language
+      def root
+        ::Code::Parser::Equality
+      end
     end
   end
 end

data/lib/code/parser/string.rb

@@ -1,87 +1,78 @@
 class Code
   class Parser
-    class String < Parslet::Parser
-      rule(:number) { ::Code::Parser::Number.new }
-      rule(:name) { ::Code::Parser::Name.new.name }
-      rule(:code) { ::Code::Parser::Code.new }
+    class String < Language
+      def code
+        ::Code::Parser::Code
+      end
 
-      rule(:single_quote) { str("'") }
-      rule(:double_quote) { str('"') }
-      rule(:backslash) { str("\\") }
-      rule(:colon) { str(":") }
-      rule(:opening_curly_bracket) { str("{") }
-      rule(:closing_curly_bracket) { str("}") }
+      def name
+        ::Code::Parser::Name
+      end
 
-      rule(:zero) { str("0") }
-      rule(:one) { str("1") }
-      rule(:two) { str("2") }
-      rule(:three) { str("3") }
-      rule(:four) { str("4") }
-      rule(:five) { str("5") }
-      rule(:six) { str("6") }
-      rule(:seven) { str("7") }
-      rule(:eight) { str("8") }
-      rule(:nine) { str("9") }
-      rule(:a) { str("a") | str("A") }
-      rule(:b) { str("b") | str("B") }
-      rule(:b) { str("b") | str("B") }
-      rule(:c) { str("c") | str("C") }
-      rule(:d) { str("d") | str("D") }
-      rule(:e) { str("e") | str("E") }
-      rule(:f) { str("f") | str("F") }
-      rule(:n) { str("n") | str("N") }
-      rule(:r) { str("r") | str("R") }
-      rule(:t) { str("t") | str("T") }
-      rule(:u) { str("u") | str("U") }
+      def single_quote
+        str("'")
+      end
 
-      rule(:interpolation) do
-        opening_curly_bracket >> code >> closing_curly_bracket
+      def double_quote
+        str('"')
       end
 
-      rule(:base_16_digit) do
-        zero | one | two | three | four | five | six | seven | eight | nine |
-          a | b | c | d | e | f
+      def backslash
+        str("\\")
       end
 
-      rule(:escaped_character) do
-        (backslash >> u >> base_16_digit.repeat(4, 4)) |
-          (backslash >> (b | f | n | r | t)) | (backslash.ignore >> any)
+      def opening_curly_bracket
+        str("{")
       end
 
-      rule(:single_quoted_character) do
-        escaped_character |
-          (opening_curly_bracket.absent? >> single_quote.absent? >> any)
+      def closing_curly_bracket
+        str("}")
       end
 
-      rule(:double_quoted_character) do
-        escaped_character |
-          (opening_curly_bracket.absent? >> double_quote.absent? >> any)
+      def colon
+        str(":")
       end
 
-      rule(:single_quoted_string) do
-        single_quote.ignore >>
-          (
-            interpolation.as(:interpolation) |
-              single_quoted_character.repeat(1).as(:characters)
-          ).repeat >> single_quote.ignore
+      def code_part
+        opening_curly_bracket << code << closing_curly_bracket.maybe
       end
 
-      rule(:double_quoted_string) do
-        double_quote.ignore >>
-          (
-            interpolation.as(:interpolation) |
-              double_quoted_character.repeat(1).as(:characters)
-          ).repeat >> double_quote.ignore
+      def single_quoted_text_part
+        (
+          backslash.ignore << opening_curly_bracket |
+            backslash.ignore << single_quote |
+            single_quote.absent << opening_curly_bracket.absent << any
+        ).repeat(1)
       end
 
-      rule(:symbol) { colon.ignore >> name }
+      def double_quoted_text_part
+        (
+          backslash.ignore << opening_curly_bracket |
+            backslash.ignore << double_quote |
+            double_quote.absent << opening_curly_bracket.absent << any
+        ).repeat(1)
+      end
 
-      rule(:string) do
-        (single_quoted_string | double_quoted_string | symbol).as(:string) |
-          number
+      def single_quoted_string
+        single_quote.ignore <<
+          (code_part.aka(:code) | single_quoted_text_part.aka(:text)).repeat <<
+          single_quote.ignore.maybe
       end
 
-      root(:string)
+      def double_quoted_string
+        double_quote.ignore <<
+          (code_part.aka(:code) | double_quoted_text_part.aka(:text)).repeat <<
+          double_quote.ignore.maybe
+      end
+
+      def symbol
+        (colon.ignore << name).aka(:text).repeat(1, 1)
+      end
+
+      def root
+        (single_quoted_string | double_quoted_string | symbol).aka(:string) |
+          ::Code::Parser::Number
+      end
     end
   end
 end

data/lib/code/parser/ternary.rb

@@ -1,25 +1,46 @@
 class Code
   class Parser
-    class Ternary < Parslet::Parser
-      rule(:defined) { ::Code::Parser::Defined.new }
+    class Ternary < Language
+      def statement
+        ::Code::Parser::Range
+      end
 
-      rule(:question_mark) { str("?") }
-      rule(:colon) { str(":") }
+      def ternary
+        ::Code::Parser::Ternary
+      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(:ternary) do
-        (
-          defined.as(:left) >> whitespace >> question_mark >> whitespace? >>
-            ternary.as(:middle) >>
-            (whitespace? >> colon >> whitespace? >> ternary.as(:right)).maybe
-        ).as(:ternary) | defined
+      def whitespace?
+        whitespace.maybe
+      end
+
+      def question_mark
+        str("?")
+      end
+
+      def colon
+        str(":")
       end
 
-      root(:ternary)
+      def root
+        (
+          statement.aka(:left) <<
+            (
+              whitespace? << question_mark << whitespace? <<
+                ternary.aka(:middle) <<
+                (
+                  whitespace? << colon << whitespace? << ternary.aka(:right)
+                ).maybe
+            ).maybe
+        )
+          .aka(:ternary)
+          .then do |output|
+            output[:ternary][:middle] ? output : output[:ternary][:left]
+          end
+      end
     end
   end
 end

data/lib/code/parser/unary_minus.rb

@@ -1,13 +1,31 @@
 class Code
   class Parser
-    class UnaryMinus < Parslet::Parser
-      rule(:power) { ::Code::Parser::Power.new }
+    class UnaryMinus < Language
+      def unary_minus
+        ::Code::Parser::UnaryMinus
+      end
 
-      rule(:minus) { str("-") }
+      def whitespace
+        ::Code::Parser::Whitespace
+      end
 
-      rule(:unary_minus) { (minus >> unary_minus).as(:unary_minus) | power }
+      def whitespace?
+        whitespace.maybe
+      end
 
-      root(:unary_minus)
+      def minus
+        str("-")
+      end
+
+      def operator
+        minus
+      end
+
+      def root
+        (operator.aka(:operator) << whitespace? << unary_minus.aka(:right)).aka(
+          :unary_minus
+        ) | ::Code::Parser::Power
+      end
     end
   end
 end

data/lib/code/parser/while.rb

@@ -1,25 +1,36 @@
 class Code
   class Parser
-    class While < Parslet::Parser
-      rule(:if_rule) { ::Code::Parser::If.new }
-      rule(:code) { ::Code::Parser::Code.new }
+    class While < Language
+      def statement
+        ::Code::Parser::If
+      end
 
-      rule(:while_keyword) { str("while") }
-      rule(:until_keyword) { str("until") }
-      rule(:end_keyword) { str("end") }
+      def whitespace
+        ::Code::Parser::Whitespace
+      end
 
-      rule(:space) { str(" ") }
-      rule(:newline) { str("\n") }
-      rule(:whitespace) { (space | newline).repeat(1) }
+      def code
+        ::Code::Parser::Code
+      end
 
-      rule(:while_rule) do
-        (
-          (while_keyword | until_keyword).as(:operator) >> whitespace >>
-            if_rule.as(:statement) >> code.as(:body) >> end_keyword
-        ).as(:while) | if_rule
+      def while_keyword
+        str("while")
+      end
+
+      def until_keyword
+        str("until")
+      end
+
+      def end_keyword
+        str("end")
       end
 
-      root(:while_rule)
+      def root
+        (
+          (while_keyword | until_keyword).aka(:operator) << whitespace <<
+            statement.aka(:statement) << code.aka(:body) << end_keyword.maybe
+        ).aka(:while) | statement
+      end
     end
   end
 end

data/lib/code/parser/whitespace.rb

@@ -0,0 +1,49 @@
+class Code
+  class Parser
+    class Whitespace < Language
+      def space
+        str(" ")
+      end
+
+      def newline
+        str("\n")
+      end
+
+      def hashtag
+        str("#")
+      end
+
+      def slash
+        str("/")
+      end
+
+      def asterisk
+        str("*")
+      end
+
+      def hash_comment
+        hashtag << (newline.absent << any).repeat << newline.maybe
+      end
+
+      def double_slash_comment
+        slash << slash << (newline.absent << any).repeat << newline.maybe
+      end
+
+      def multi_line_comment
+        slash << asterisk << ((asterisk << slash).absent << any).repeat <<
+          asterisk.maybe << slash.maybe
+      end
+
+      def without_newline
+        (space | multi_line_comment).repeat(1)
+      end
+
+      def root
+        (
+          space | newline | hash_comment | double_slash_comment |
+            multi_line_comment
+        ).repeat(1)
+      end
+    end
+  end
+end

data/lib/code/parser.rb

@@ -1,4 +1,19 @@
 class Code
   class Parser
+    def initialize(input)
+      @input = input
+    end
+
+    def self.parse(input)
+      new(input).parse
+    end
+
+    def parse
+      ::Code::Parser::Code.parse(input)
+    end
+
+    private
+
+    attr_reader :input
   end
 end