code-ruby-parser 0.1.0

data/lib/code/parser/equal.rb

@@ -0,0 +1,39 @@
+class Code
+  class Parser
+    class Equal < ::Code::Parser
+      def parse
+        left = parse_subclass(::Code::Parser::Rescue)
+
+        previous_cursor = cursor
+
+        comments_before = parse_comments
+
+        if operator = match(EQUALS)
+          previous_cursor = cursor
+          comments_after = parse_comments
+
+          right = parse_subclass(::Code::Parser::Equal)
+
+          if right
+            {
+              equal: {
+                left: left,
+                right: right,
+                comments_before: comments_before,
+                comments_after: comments_after
+              }.compact
+            }
+          else
+            @cursor = previous_cursor
+            buffer!
+            { equal: { left: left, comments_before: comments_before } }
+          end
+        else
+          @cursor = previous_cursor
+          buffer!
+          left
+        end
+      end
+    end
+  end
+end

data/lib/code/parser/equality.rb

@@ -0,0 +1,20 @@
+class Code
+  class Parser
+    class Equality < ::Code::Parser
+      def parse
+        parse_subclass(
+          ::Code::Parser::Operation,
+          operators: [
+            EQUAL + EQUAL + EQUAL,
+            LESSER + EQUAL + GREATER,
+            EQUAL + TILDE,
+            EXCLAMATION_POINT + TILDE,
+            EQUAL + EQUAL,
+            EXCLAMATION_POINT + EQUAL
+          ],
+          subclass: ::Code::Parser::While
+        )
+      end
+    end
+  end
+end

data/lib/code/parser/error/syntax_error.rb

@@ -0,0 +1,36 @@
+class Code
+  class Parser
+    class Error
+      class SyntaxError < ::Code::Parser::Error
+        def initialize(
+          message,
+          input:,
+          line:,
+          column:,
+          offset_lines:,
+          offset_columns:
+        )
+          @message = message
+          @input = input
+          @line = line
+          @column = column
+          @offset_lines = offset_lines
+          @offset_columns = offset_columns
+        end
+
+        def message
+          @message + "\n\n" + line_message + "\n" + " " * column +
+            "^" * offset_columns
+        end
+
+        private
+
+        def line_message
+          input.lines[line..(line + offset_lines)].join
+        end
+
+        attr_reader :input, :line, :column, :offset_lines, :offset_columns
+      end
+    end
+  end
+end

data/lib/code/parser/error.rb

@@ -0,0 +1,6 @@
+class Code
+  class Parser
+    class Error < ::StandardError
+    end
+  end
+end

data/lib/code/parser/function.rb

@@ -0,0 +1,109 @@
+class Code
+  class Parser
+    class Function < ::Code::Parser
+      def parse
+        return parse_next unless next?(OPENING_PARENTHESIS)
+        previous_cursor = cursor
+        match(OPENING_PARENTHESIS)
+        parameters_comments = parse_comments
+        parameters = parse_parameters
+        match(CLOSING_PARENTHESIS)
+        comments_before = parse_comments
+        if match(EQUAL + GREATER)
+          comments_after = parse_comments
+          if match(OPENING_CURLY_BRACKET)
+            body = parse_code
+            match(CLOSING_CURLY_BRACKET)
+            {
+              function: {
+                parameters: parameters,
+                body: body,
+                parameters_comments: parameters_comments,
+                comments_before: comments_before,
+                comments_after: comments_after
+              }.compact
+            }
+          else
+            buffer!
+            @cursor = previous_cursor
+            parse_next
+          end
+        else
+          buffer!
+          @cursor = previous_cursor
+          parse_next
+        end
+      end
+
+      def parse_next
+        parse_subclass(::Code::Parser::ChainedCall)
+      end
+
+      def parse_parameters
+        parameters = []
+
+        parameters << (parse_keyword_parameter || parse_regular_parameter)
+
+        while match(COMMA) && !end_of_input?
+          parameters << (parse_keyword_parameter || parse_regular_parameter)
+        end
+
+        parameters.compact.empty? ? nil : parameters.compact
+      end
+
+      def parse_keyword_parameter
+        previous_cursor = cursor
+
+        comments_before = parse_comments
+
+        key = parse_subclass(::Code::Parser::Identifier)
+
+        comments_after = parse_comments
+
+        if key && (match(COLON) || match(EQUAL + GREATER))
+          default = parse_code
+
+          {
+            default: default,
+            keyword: true,
+            comments_before: comments_before,
+            comments_after: comments_after,
+            **key
+          }.compact
+        else
+          @cursor = previous_cursor
+          buffer!
+          return
+        end
+      end
+
+      def parse_regular_parameter
+        previous_cursor = cursor
+        comments_before = parse_comments
+
+        identifier = parse_subclass(::Code::Parser::Identifier)
+
+        comments_after = parse_comments
+
+        if identifier
+          if match(EQUAL)
+            default = parse_code
+          else
+            default = nil
+          end
+
+          {
+            default: default,
+            comments_before: comments_before,
+            comments_after: comments_after,
+            **identifier
+          }.compact
+        else
+          @cursor = previous_cursor
+          buffer!
+          return
+        end
+      end
+    end
+  end
+end

data/lib/code/parser/greater_than.rb

@@ -0,0 +1,13 @@
+class Code
+  class Parser
+    class GreaterThan < ::Code::Parser
+      def parse
+        parse_subclass(
+          ::Code::Parser::Operation,
+          operators: [GREATER + EQUAL, LESSER + EQUAL, GREATER, LESSER],
+          subclass: ::Code::Parser::BitwiseOr
+        )
+      end
+    end
+  end
+end

data/lib/code/parser/group.rb

@@ -0,0 +1,15 @@
+class Code
+  class Parser
+    class Group < ::Code::Parser
+      def parse
+        if match(OPENING_PARENTHESIS)
+          code = parse_subclass(::Code::Parser::Code)
+          match(CLOSING_PARENTHESIS)
+          { group: code }
+        else
+          parse_subclass(::Code::Parser::Call)
+        end
+      end
+    end
+  end
+end

data/lib/code/parser/identifier.rb

@@ -0,0 +1,54 @@
+class Code
+  class Parser
+    class Identifier < ::Code::Parser
+      def initialize(input, simple: false, **kargs)
+        super(input, **kargs)
+        @simple = simple
+      end
+
+      def parse
+        return if end_of_input?
+
+        previous_cursor = cursor
+
+        if !simple? && match(AMPERSAND) && !next?(SPECIAL)
+          kind = :block
+        elsif !simple && match(ASTERISK + ASTERISK) && !next?(SPECIAL)
+          kind = :keyword
+        elsif !simple? && match(ASTERISK) && !next?(SPECIAL)
+          kind = :regular
+        elsif !next?(SPECIAL)
+          kind = nil
+        else
+          @cursor = previous_cursor
+          buffer!
+          return
+        end
+
+        buffer!
+
+        consume while !next?(SPECIAL) && !end_of_input?
+
+        match(QUESTION_MARK) || match(EXCLAMATION_POINT) if !simple?
+
+        name = buffer!
+
+        if KEYWORDS.include?(name)
+          @cursor = previous_cursor
+          buffer!
+          return
+        else
+          { name: name, kind: kind }.compact
+        end
+      end
+
+      private
+
+      attr_reader :simple
+
+      def simple?
+        !!simple
+      end
+    end
+  end
+end

data/lib/code/parser/if.rb

@@ -0,0 +1,81 @@
+class Code
+  class Parser
+    class If < ::Code::Parser
+      def parse
+        if first_operator = match([IF_KEYWORD, UNLESS_KEYWORD])
+          previous_cursor = cursor
+          first_comments = parse_comments
+          first_condition = parse_subclass(::Code::Parser::If)
+
+          if first_condition
+            first_body = parse_code
+
+            others = []
+
+            while (other = parse_else) || (other = parse_elsif)
+              others << other
+            end
+
+            others = nil if others.empty?
+
+            match(END_KEYWORD)
+
+            {
+              if: {
+                first_operator: first_operator,
+                first_comments: first_comments,
+                first_condition: first_condition,
+                first_body: first_body,
+                others: others
+              }.compact
+            }
+          else
+            @cursor = previous_cursor
+            buffer!
+            parse_subclass(::Code::Parser::IfModifier)
+          end
+        else
+          parse_subclass(::Code::Parser::IfModifier)
+        end
+      end
+
+      private
+
+      def parse_else
+        return unless match(ELSE_KEYWORD)
+        comments_before = parse_comments
+
+        operator = match([IF_KEYWORD, UNLESS_KEYWORD]) || ELSE_KEYWORD
+
+        comments_after = parse_comments
+
+        condition = parse_subclass(::Code::Parser::If)
+
+        body = parse_code
+
+        {
+          operator: operator,
+          comments_before: comments_before,
+          comments_after: comments_after,
+          condition: condition,
+          body: body
+        }.compact
+      end
+
+      def parse_elsif
+        return unless operator = match([ELSIF_KEYWORD, ELSUNLESS_KEYWORD])
+
+        comments = parse_comments
+        condition = parse_subclass(::Code::Parser::If)
+        body = parse_code
+
+        {
+          operator: operator,
+          comments: comments,
+          condition: condition,
+          body: body
+        }.compact
+      end
+    end
+  end
+end

data/lib/code/parser/if_modifier.rb

@@ -0,0 +1,39 @@
+class Code
+  class Parser
+    class IfModifier < ::Code::Parser
+      def parse
+        left = parse_subclass(::Code::Parser::OrKeyword)
+
+        previous_cursor = cursor
+
+        comments_before = parse_comments(whitespace: [SPACE])
+
+        if left && (operator = match(IF_KEYWORD)) ||
+             (operator = match(UNLESS_KEYWORD))
+          comments_after = parse_comments
+          right = parse_subclass(::Code::Parser::IfModifier)
+
+          if right
+            {
+              if_modifier: {
+                left: left,
+                right: right,
+                operator: operator,
+                comments_before: comments_before,
+                comments_after: comments_after
+              }.compact
+            }
+          else
+            @cursor = previous_cursor
+            buffer!
+            left
+          end
+        else
+          @cursor = previous_cursor
+          buffer!
+          left
+        end
+      end
+    end
+  end
+end

data/lib/code/parser/list.rb

@@ -0,0 +1,20 @@
+class Code
+  class Parser
+    class List < ::Code::Parser
+      def parse
+        if match(OPENING_SQUARE_BRACKET)
+          list = []
+
+          list << parse_code
+          list << parse_code while match(COMMA) && !end_of_input?
+
+          match(CLOSING_SQUARE_BRACKET)
+
+          { list: list.reject(&:empty?) }
+        else
+          parse_subclass(::Code::Parser::String)
+        end
+      end
+    end
+  end
+end

data/lib/code/parser/multiplication.rb

@@ -0,0 +1,13 @@
+class Code
+  class Parser
+    class Multiplication < ::Code::Parser
+      def parse
+        parse_subclass(
+          ::Code::Parser::Operation,
+          operators: [ASTERISK, SLASH, PERCENT],
+          subclass: ::Code::Parser::UnaryMinus
+        )
+      end
+    end
+  end
+end

data/lib/code/parser/negation.rb

@@ -0,0 +1,18 @@
+class Code
+  class Parser
+    class Negation < ::Code::Parser
+      def parse
+        if operator = match([EXCLAMATION_POINT, TILDE, PLUS])
+          {
+            negation: {
+              operator: operator,
+              statement: parse_subclass(::Code::Parser::Negation)
+            }
+          }
+        else
+          parse_subclass(::Code::Parser::Function)
+        end
+      end
+    end
+  end
+end

data/lib/code/parser/not_keyword.rb

@@ -0,0 +1,24 @@
+class Code
+  class Parser
+    class NotKeyword < ::Code::Parser
+      def parse
+        previous_cursor = cursor
+
+        if match(NOT_KEYWORD)
+          comments = parse_comments
+          right = parse_subclass(::Code::Parser::NotKeyword)
+
+          if right
+            { not: { right: right, comments: comments }.compact }
+          else
+            @cursor = previous_cursor
+            buffer!
+            parse_subclass(::Code::Parser::Equal)
+          end
+        else
+          parse_subclass(::Code::Parser::Equal)
+        end
+      end
+    end
+  end
+end

data/lib/code/parser/nothing.rb

@@ -0,0 +1,13 @@
+class Code
+  class Parser
+    class Nothing < ::Code::Parser
+      def parse
+        if match(NOTHING_KEYWORDS)
+          { nothing: buffer }
+        else
+          parse_subclass(::Code::Parser::Group)
+        end
+      end
+    end
+  end
+end

data/lib/code/parser/number.rb

@@ -0,0 +1,39 @@
+class Code
+  class Parser
+    class Number < ::Code::Parser
+      def parse
+        if match(DIGITS)
+          if match(X)
+            parse_base(16)
+          elsif match(O)
+            parse_base(8)
+          elsif match(B)
+            parse_base(2)
+          else
+            consume while (next?(DIGITS) || next?(UNDERSCORE)) && !end_of_input?
+
+            if next?(DOT) && next_next?(DIGITS)
+              consume
+              while (next?(DIGITS) || next?(UNDERSCORE)) && !end_of_input?
+                consume
+              end
+
+              { decimal: buffer.gsub(UNDERSCORE, EMPTY_STRING) }
+            else
+              { integer: buffer.gsub(UNDERSCORE, EMPTY_STRING).to_i }
+            end
+          end
+        else
+          parse_subclass(::Code::Parser::Boolean)
+        end
+      end
+
+      def parse_base(base)
+        buffer!
+        consume while (next?(DIGITS) || next?(UNDERSCORE)) && !end_of_input?
+
+        { integer: buffer.gsub(UNDERSCORE, EMPTY_STRING).to_i(base) }
+      end
+    end
+  end
+end

data/lib/code/parser/operation.rb

@@ -0,0 +1,44 @@
+class Code
+  class Parser
+    class Operation < ::Code::Parser
+      def initialize(input, operators:, subclass:, **kargs)
+        super(input, **kargs)
+
+        @operators = operators
+        @subclass = subclass
+      end
+
+      def parse
+        previous_cursor = cursor
+        left = parse_subclass(subclass)
+        right = []
+        previous_cursor = cursor
+        comments = parse_comments
+
+        while operator = match(operators)
+          comments = parse_comments
+          statement = parse_subclass(subclass)
+          right << {
+            comments: comments,
+            statement: statement,
+            operator: operator
+          }.compact
+        end
+
+        if right.empty?
+          @cursor = previous_cursor
+          buffer!
+          left
+        else
+          {
+            operation: { left: left, comments: comments, right: right }.compact
+          }
+        end
+      end
+
+      private
+
+      attr_reader :operators, :subclass
+    end
+  end
+end

data/lib/code/parser/or_keyword.rb

@@ -0,0 +1,13 @@
+class Code
+  class Parser
+    class OrKeyword < ::Code::Parser
+      def parse
+        parse_subclass(
+          ::Code::Parser::Operation,
+          operators: [AND_KEYWORD, OR_KEYWORD],
+          subclass: ::Code::Parser::NotKeyword
+        )
+      end
+    end
+  end
+end

data/lib/code/parser/or_operator.rb

@@ -0,0 +1,13 @@
+class Code
+  class Parser
+    class OrOperator < ::Code::Parser
+      def parse
+        parse_subclass(
+          ::Code::Parser::Operation,
+          operators: [PIPE + PIPE],
+          subclass: ::Code::Parser::GreaterThan
+        )
+      end
+    end
+  end
+end

data/lib/code/parser/power.rb

@@ -0,0 +1,33 @@
+class Code
+  class Parser
+    class Power < ::Code::Parser
+      def parse
+        previous_cursor = cursor
+        left = parse_subclass(::Code::Parser::Negation)
+        comments_before = parse_comments
+        if match(ASTERISK + ASTERISK)
+          comments_after = parse_comments
+          right = parse_subclass(::Code::Parser::Power)
+          if right
+            {
+              power: {
+                left: left,
+                right: right,
+                comments_before: comments_before,
+                comments_after: comments_after
+              }.compact
+            }
+          else
+            @cursor = previous_cursor
+            buffer!
+            parse_subclass(::Code::Parser::Negation)
+          end
+        else
+          @cursor = previous_cursor
+          buffer!
+          parse_subclass(::Code::Parser::Negation)
+        end
+      end
+    end
+  end
+end

data/lib/code/parser/range.rb

@@ -0,0 +1,13 @@
+class Code
+  class Parser
+    class Range < ::Code::Parser
+      def parse
+        parse_subclass(
+          ::Code::Parser::Operation,
+          operators: [DOT + DOT + DOT, DOT + DOT],
+          subclass: ::Code::Parser::OrOperator
+        )
+      end
+    end
+  end
+end