language-ruby 0.5.6 → 0.6.1

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

data/lib/code/parser/shift.rb

@@ -1,21 +0,0 @@
-class Code
-  class Parser
-    class Shift < Operation
-      def statement
-        ::Code::Parser::Addition
-      end
-
-      def greater
-        str(">")
-      end
-
-      def lesser
-        str("<")
-      end
-
-      def operator
-        (greater << greater) | (lesser << lesser)
-      end
-    end
-  end
-end

data/lib/code/parser/splat.rb

@@ -1,31 +0,0 @@
-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,9 +0,0 @@
-class Code
-  class Parser
-    class Statement < Language
-      def root
-        ::Code::Parser::Equality
-      end
-    end
-  end
-end

data/lib/code/parser/string.rb

@@ -1,78 +0,0 @@
-class Code
-  class Parser
-    class String < Language
-      def code
-        ::Code::Parser::Code
-      end
-
-      def name
-        ::Code::Parser::Name
-      end
-
-      def single_quote
-        str("'")
-      end
-
-      def double_quote
-        str('"')
-      end
-
-      def backslash
-        str("\\")
-      end
-
-      def opening_curly_bracket
-        str("{")
-      end
-
-      def closing_curly_bracket
-        str("}")
-      end
-
-      def colon
-        str(":")
-      end
-
-      def code_part
-        opening_curly_bracket << code << closing_curly_bracket.maybe
-      end
-
-      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
-
-      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
-
-      def single_quoted_string
-        single_quote.ignore <<
-          (code_part.aka(:code) | single_quoted_text_part.aka(:text)).repeat <<
-          single_quote.ignore.maybe
-      end
-
-      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,46 +0,0 @@
-class Code
-  class Parser
-    class Ternary < Language
-      def statement
-        ::Code::Parser::Range
-      end
-
-      def ternary
-        ::Code::Parser::Ternary
-      end
-
-      def whitespace
-        ::Code::Parser::Whitespace
-      end
-
-      def whitespace?
-        whitespace.maybe
-      end
-
-      def question_mark
-        str("?")
-      end
-
-      def colon
-        str(":")
-      end
-
-      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,31 +0,0 @@
-class Code
-  class Parser
-    class UnaryMinus < Language
-      def unary_minus
-        ::Code::Parser::UnaryMinus
-      end
-
-      def whitespace
-        ::Code::Parser::Whitespace
-      end
-
-      def whitespace?
-        whitespace.maybe
-      end
-
-      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,36 +0,0 @@
-class Code
-  class Parser
-    class While < Language
-      def statement
-        ::Code::Parser::If
-      end
-
-      def whitespace
-        ::Code::Parser::Whitespace
-      end
-
-      def code
-        ::Code::Parser::Code
-      end
-
-      def while_keyword
-        str("while")
-      end
-
-      def until_keyword
-        str("until")
-      end
-
-      def end_keyword
-        str("end")
-      end
-
-      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

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