code-ruby 0.3.1 → 0.5.0

data/lib/code/parser/list.rb

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

data/lib/code/parser/multiplication.rb

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

data/lib/code/parser/name.rb

@@ -1,89 +1,101 @@
 class Code
   class Parser
-    class Name < Parslet::Parser
-      rule(:space) { str(" ") }
-      rule(:newline) { str("\n") }
-      rule(:comma) { str(",") }
-      rule(:colon) { str(":") }
-      rule(:dot) { str(".") }
-      rule(:single_quote) { str("'") }
-      rule(:double_quote) { str('"') }
-      rule(:opening_curly_bracket) { str("{") }
-      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") }
-      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(:digit) do
-        zero | one | two | three | four | five | six | seven | eight | nine
-      end
-
-      rule(:name_character) do
-        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
-        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
-
-      rule(:name_rule) { name.as(:name) }
-
-      root(:name_rule)
+    class Name < Language
+      def space
+        str(" ")
+      end
+
+      def newline
+        str("\n")
+      end
+
+      def comma
+        str(",")
+      end
+
+      def equal
+        str("=")
+      end
+
+      def colon
+        str(":")
+      end
+
+      def opening_curly_bracket
+        str("{")
+      end
+
+      def closing_curly_bracket
+        str("}")
+      end
+
+      def opening_square_bracket
+        str("[")
+      end
+
+      def closing_square_bracket
+        str("]")
+      end
+
+      def opening_parenthesis
+        str("(")
+      end
+
+      def closing_parenthesis
+        str(")")
+      end
+
+      def single_quote
+        str("'")
+      end
+
+      def double_quote
+        str('"')
+      end
+
+      def dot
+        str(".")
+      end
+
+      def pipe
+        str("|")
+      end
+
+      def ampersand
+        str("&")
+      end
+
+      def do_keyword
+        str("do")
+      end
+
+      def end_keyword
+        str("end")
+      end
+
+      def elsif_keyword
+        str("elsif")
+      end
+
+      def else_keyword
+        str("else")
+      end
+
+      def special_character
+        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
+      end
+
+      def character
+        special_character.absent << any
+      end
+
+      def root
+        do_keyword.absent << end_keyword.absent << elsif_keyword.absent <<
+          else_keyword.absent << character.repeat(1)
+      end
     end
   end
 end

data/lib/code/parser/negation.rb

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

data/lib/code/parser/not_keyword.rb

@@ -1,21 +1,23 @@
 class Code
   class Parser
-    class NotKeyword < Parslet::Parser
-      rule(:equal) { ::Code::Parser::Equal.new }
-
-      rule(:not_keyword) { str("not") }
-
-      rule(:operator) { not_keyword }
+    class NotKeyword < Language
+      def not_class
+        ::Code::Parser::NotKeyword
+      end
 
-      rule(:space) { str(" ") }
-      rule(:newline) { str("\n") }
-      rule(:whitespace) { (space | newline).repeat(1) }
+      def whitespace
+        ::Code::Parser::Whitespace
+      end
 
-      rule(:not_rule) do
-        (not_keyword >> whitespace >> not_rule).as(:not_keyword) | equal
+      def not_keyword
+        str("not")
       end
 
-      root(:not_rule)
+      def root
+        (not_keyword.aka(:operator) << whitespace << not_class.aka(:right)).aka(
+          :not
+        ) | ::Code::Parser::Equal
+      end
     end
   end
 end

data/lib/code/parser/nothing.rb

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

data/lib/code/parser/number.rb

@@ -1,98 +1,154 @@
 class Code
   class Parser
-    class Number < Parslet::Parser
-      rule(:boolean) { ::Code::Parser::Boolean.new }
-
-      rule(:dot) { str(".") }
-      rule(:plus) { str("+") }
-      rule(:minus) { str("-") }
-
-      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(:o) { str("o") | str("O") }
-      rule(:x) { str("x") | str("X") }
-
-      # sign
-
-      rule(:sign) { plus | minus }
-
-      # base 2
-
-      rule(:base_2_digit) { zero | one }
-
-      rule(:base_2_number) { zero.ignore >> b.ignore >> base_2_digit.repeat(1) }
-
-      # base 8
-
-      rule(:base_8_digit) do
-        zero | one | two | three | four | five | six | seven
+    class Number < Language
+      def number
+        ::Code::Parser::Number
       end
 
-      rule(:base_8_number) { zero.ignore >> o.ignore >> base_8_digit.repeat(1) }
+      def zero
+        str("0")
+      end
 
-      # base 10
+      def one
+        str("1")
+      end
 
-      rule(:base_10_digit) do
-        zero | one | two | three | four | five | six | seven | eight | nine
+      def two
+        str("2")
+      end
+
+      def three
+        str("3")
+      end
+
+      def four
+        str("4")
+      end
+
+      def five
+        str("5")
       end
 
-      rule(:base_10_whole) { base_10_digit.repeat(1) }
+      def six
+        str("6")
+      end
 
-      rule(:base_10_exponent) { e.ignore >> base_10_number }
+      def seven
+        str("7")
+      end
+
+      def eight
+        str("8")
+      end
 
-      rule(:base_10_integer) do
-        sign.as(:sign).maybe >> base_10_whole.as(:whole) >>
-          base_10_exponent.as(:exponent).maybe
+      def nine
+        str("9")
       end
 
-      rule(:base_10_decimal_decimal) { dot.ignore >> base_10_digit.repeat(1) }
+      def dot
+        str(".")
+      end
+
+      def a
+        str("a") | str("A")
+      end
+
+      def b
+        str("b") | str("B")
+      end
+
+      def c
+        str("c") | str("C")
+      end
+
+      def d
+        str("d") | str("D")
+      end
+
+      def e
+        str("e") | str("E")
+      end
+
+      def f
+        str("f") | str("F")
+      end
 
-      rule(:base_10_decimal) do
-        sign.as(:sign).maybe >> base_10_whole.as(:whole) >>
-          base_10_decimal_decimal.as(:decimal) >>
-          base_10_exponent.as(:exponent).maybe
+      def o
+        str("o") | str("O")
       end
 
-      rule(:base_10_number) do
-        base_10_decimal.as(:decimal) | base_10_integer.as(:integer)
+      def x
+        str("x") | str("X")
       end
 
-      # base 16
+      def underscore
+        str("_")
+      end
 
-      rule(:base_16_digit) do
+      def base_16_digit
         zero | one | two | three | four | five | six | seven | eight | nine |
           a | b | c | d | e | f
       end
 
-      rule(:base_16_number) do
-        zero.ignore >> x.ignore >> base_16_digit.repeat(1)
+      def base_10_digit
+        zero | one | two | three | four | five | six | seven | eight | nine
       end
 
-      # number
+      def base_8_digit
+        zero | one | two | three | four | five | six | seven
+      end
 
-      rule(:number) do
-        (
-          base_2_number.as(:base_2) | base_8_number.as(:base_8) |
-            base_16_number.as(:base_16) | base_10_number.as(:base_10)
-        ).as(:number) | boolean
+      def base_2_digit
+        zero | one
+      end
+
+      def base_16_whole
+        base_16_digit << (underscore.ignore | base_16_digit).repeat
       end
 
-      root(:number)
+      def base_10_whole
+        base_10_digit << (underscore.ignore | base_10_digit).repeat
+      end
+
+      def base_8_whole
+        base_8_digit << (underscore.ignore | base_8_digit).repeat
+      end
+
+      def base_2_whole
+        base_2_digit << (underscore.ignore | base_2_digit).repeat
+      end
+
+      def exponent
+        (e << number).aka(:exponent)
+      end
+
+      def decimal
+        (base_10_whole << dot << base_10_whole).aka(:decimal) << exponent.maybe
+      end
+
+      def base_16_number
+        zero.ignore << x.ignore << base_16_whole
+      end
+
+      def base_10_number
+        base_10_whole.aka(:whole) << exponent.maybe
+      end
+
+      def base_8_number
+        zero.ignore << o.ignore << base_8_whole
+      end
+
+      def base_2_number
+        zero.ignore << b.ignore << base_2_whole
+      end
+
+      def root
+        (
+          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
+      end
     end
   end
 end

data/lib/code/parser/operation.rb

@@ -0,0 +1,35 @@
+class Code
+  class Parser
+    class Operation < Language
+      def statement
+        raise NotImplementedError
+      end
+
+      def whitespace
+        ::Code::Parser::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(:operation)
+          .then do |output|
+            output[:operation][:others] ? output : output[:operation][:first]
+          end
+      end
+    end
+  end
+end