language-ruby 0.5.6 → 0.6.0

data/lib/code/parser/if.rb

@@ -1,63 +0,0 @@
-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

@@ -1,55 +0,0 @@
-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

@@ -1,42 +0,0 @@
-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

@@ -1,25 +0,0 @@
-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

@@ -1,107 +0,0 @@
-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 separator
-        special_character
-      end
-
-      def root
-        (do_keyword << separator).absent <<
-          (else_keyword << separator).absent <<
-          (elsif_keyword << separator).absent <<
-          (end_keyword << separator).absent << character.repeat(1)
-      end
-    end
-  end
-end

data/lib/code/parser/negation.rb

@@ -1,30 +0,0 @@
-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

@@ -1,23 +0,0 @@
-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

@@ -1,22 +0,0 @@
-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

@@ -1,154 +0,0 @@
-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

data/lib/code/parser/operation.rb

@@ -1,35 +0,0 @@
-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

data/lib/code/parser/or_keyword.rb

@@ -1,21 +0,0 @@
-class Code
-  class Parser
-    class OrKeyword < Operation
-      def statement
-        ::Code::Parser::NotKeyword
-      end
-
-      def or_keyword
-        str("or")
-      end
-
-      def and_keyword
-        str("and")
-      end
-
-      def operator
-        or_keyword | and_keyword
-      end
-    end
-  end
-end

data/lib/code/parser/or_operator.rb

@@ -1,17 +0,0 @@
-class Code
-  class Parser
-    class OrOperator < Operation
-      def statement
-        ::Code::Parser::AndOperator
-      end
-
-      def pipe
-        str("|")
-      end
-
-      def operator
-        pipe << pipe
-      end
-    end
-  end
-end

data/lib/code/parser/power.rb

@@ -1,43 +0,0 @@
-class Code
-  class Parser
-    class Power < Language
-      def power
-        ::Code::Parser::Power
-      end
-
-      def statement
-        ::Code::Parser::Negation
-      end
-
-      def whitespace
-        ::Code::Parser::Whitespace
-      end
-
-      def whitespace?
-        whitespace.maybe
-      end
-
-      def asterisk
-        str("*")
-      end
-
-      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,17 +0,0 @@
-class Code
-  class Parser
-    class Range < Operation
-      def statement
-        ::Code::Parser::OrOperator
-      end
-
-      def dot
-        str(".")
-      end
-
-      def operator
-        (dot << dot << dot) | (dot << dot)
-      end
-    end
-  end
-end

data/lib/code/parser/rescue.rb

@@ -1,39 +0,0 @@
-class Code
-  class Parser
-    class Rescue < Language
-      def statement
-        ::Code::Parser::Ternary
-      end
-
-      def rescue_class
-        ::Code::Parser::Rescue
-      end
-
-      def whitespace
-        ::Code::Parser::Whitespace
-      end
-
-      def whitespace?
-        whitespace.maybe
-      end
-
-      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