language-ruby 0.5.0

data/lib/code/parser/equality.rb

@@ -0,0 +1,35 @@
+class Code
+  class Parser
+    class Equality < Operation
+      def statement
+        ::Code::Parser::Splat
+      end
+
+      def equal
+        str("=")
+      end
+
+      def greater
+        str(">")
+      end
+
+      def lesser
+        str("<")
+      end
+
+      def exclamation_point
+        str("!")
+      end
+
+      def tilde
+        str("~")
+      end
+
+      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

@@ -0,0 +1,85 @@
+class Code
+  class Parser
+    class Function < Language
+      def name
+        ::Code::Parser::Name
+      end
+
+      def code
+        ::Code::Parser::Code
+      end
+
+      def code_present
+        ::Code::Parser::Code.new.present
+      end
+
+      def whitespace
+        ::Code::Parser::Whitespace
+      end
+
+      def whitespace?
+        whitespace.maybe
+      end
+
+      def opening_parenthesis
+        str("(")
+      end
+
+      def closing_parenthesis
+        str(")")
+      end
+
+      def colon
+        str(":")
+      end
+
+      def comma
+        str(",")
+      end
+
+      def equal
+        str("=")
+      end
+
+      def greater
+        str(">")
+      end
+
+      def opening_curly_bracket
+        str("{")
+      end
+
+      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

@@ -0,0 +1,22 @@
+class Code
+  class Parser
+    class Group < Language
+      def code
+        ::Code::Parser::Code
+      end
+
+      def opening_parenthesis
+        str("(")
+      end
+
+      def closing_parenthesis
+        str(")")
+      end
+
+      def root
+        (opening_parenthesis << code << closing_parenthesis.maybe).aka(:group) |
+          ::Code::Parser::Call
+      end
+    end
+  end
+end

data/lib/code/parser/if.rb

@@ -0,0 +1,63 @@
+class Code
+  class Parser
+    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
+
+      def if_keyword
+        str("if")
+      end
+
+      def unless_keyword
+        str("unless")
+      end
+
+      def elsif_keyword
+        str("elsif")
+      end
+
+      def else_keyword
+        str("else")
+      end
+
+      def end_keyword
+        str("end")
+      end
+
+      def root
+        (
+          (if_keyword | unless_keyword).aka(:first_operator) << whitespace <<
+            statement.aka(:first_statement) << code.aka(:first_body) <<
+            (
+              (
+                elsif_keyword.aka(:operator) << whitespace <<
+                  statement.aka(:statement) << code.aka(:body)
+              ) |
+                (
+                  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
+    end
+  end
+end

data/lib/code/parser/if_modifier.rb

@@ -0,0 +1,55 @@
+class Code
+  class Parser
+    class IfModifier < Language
+      def statement
+        ::Code::Parser::OrKeyword
+      end
+
+      def if_modifier
+        ::Code::Parser::IfModifier
+      end
+
+      def whitespace
+        ::Code::Parser::Whitespace.new.without_newline
+      end
+
+      def whitespace?
+        whitespace.maybe
+      end
+
+      def if_keyword
+        str("if")
+      end
+
+      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
+
+      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

data/lib/code/parser/list.rb

@@ -0,0 +1,42 @@
+class Code
+  class Parser
+    class List < Language
+      def code
+        ::Code::Parser::Code.new.present
+      end
+
+      def whitespace
+        ::Code::Parser::Whitespace
+      end
+
+      def whitespace?
+        whitespace.maybe
+      end
+
+      def opening_square_bracket
+        str("[")
+      end
+
+      def closing_square_bracket
+        str("]")
+      end
+
+      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

@@ -0,0 +1,25 @@
+class Code
+  class Parser
+    class Multiplication < Operation
+      def statement
+        ::Code::Parser::UnaryMinus
+      end
+
+      def asterisk
+        str("*")
+      end
+
+      def slash
+        str("/")
+      end
+
+      def percent
+        str("%")
+      end
+
+      def operator
+        asterisk | slash | percent
+      end
+    end
+  end
+end

data/lib/code/parser/name.rb

@@ -0,0 +1,101 @@
+class Code
+  class Parser
+    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

@@ -0,0 +1,30 @@
+class Code
+  class Parser
+    class Negation < Language
+      def exclamation_point
+        str("!")
+      end
+
+      def tilde
+        str("~")
+      end
+
+      def plus
+        str("+")
+      end
+
+      def operator
+        exclamation_point | tilde | plus
+      end
+
+      def negation
+        ::Code::Parser::Negation
+      end
+
+      def root
+        (operator.aka(:operator) << negation.aka(:right)).aka(:negation) |
+          ::Code::Parser::Function
+      end
+    end
+  end
+end

data/lib/code/parser/not_keyword.rb

@@ -0,0 +1,23 @@
+class Code
+  class Parser
+    class NotKeyword < Language
+      def not_class
+        ::Code::Parser::NotKeyword
+      end
+
+      def whitespace
+        ::Code::Parser::Whitespace
+      end
+
+      def not_keyword
+        str("not")
+      end
+
+      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

@@ -0,0 +1,22 @@
+class Code
+  class Parser
+    class Nothing < Language
+      def nothing_keyword
+        str("nothing")
+      end
+
+      def null_keyword
+        str("null")
+      end
+
+      def nil_keyword
+        str("nil")
+      end
+
+      def root
+        (nothing_keyword | null_keyword | nil_keyword).aka(:nothing) |
+          ::Code::Parser::Group
+      end
+    end
+  end
+end

data/lib/code/parser/number.rb

@@ -0,0 +1,154 @@
+class Code
+  class Parser
+    class Number < Language
+      def number
+        ::Code::Parser::Number
+      end
+
+      def zero
+        str("0")
+      end
+
+      def one
+        str("1")
+      end
+
+      def two
+        str("2")
+      end
+
+      def three
+        str("3")
+      end
+
+      def four
+        str("4")
+      end
+
+      def five
+        str("5")
+      end
+
+      def six
+        str("6")
+      end
+
+      def seven
+        str("7")
+      end
+
+      def eight
+        str("8")
+      end
+
+      def nine
+        str("9")
+      end
+
+      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
+
+      def o
+        str("o") | str("O")
+      end
+
+      def x
+        str("x") | str("X")
+      end
+
+      def underscore
+        str("_")
+      end
+
+      def base_16_digit
+        zero | one | two | three | four | five | six | seven | eight | nine |
+          a | b | c | d | e | f
+      end
+
+      def base_10_digit
+        zero | one | two | three | four | five | six | seven | eight | nine
+      end
+
+      def base_8_digit
+        zero | one | two | three | four | five | six | seven
+      end
+
+      def base_2_digit
+        zero | one
+      end
+
+      def base_16_whole
+        base_16_digit << (underscore.ignore | base_16_digit).repeat
+      end
+
+      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