code-ruby-parser 0.1.8 → 0.2.0

data/lib/code/parser/call.rb

@@ -1,183 +0,0 @@
-class Code
-  class Parser
-    class Call < ::Code::Parser
-      def parse
-        name = parse_subclass(::Code::Parser::Name)
-        return unless name
-
-        if match(OPENING_PARENTHESIS)
-          arguments = []
-
-          arguments << (parse_keyword_argument || parse_regular_argument)
-
-          while match(COMMA) && !end_of_input?
-            arguments << (parse_keyword_argument || parse_regular_argument)
-          end
-
-          arguments.compact!
-
-          match(CLOSING_PARENTHESIS)
-        else
-          arguments = nil
-        end
-
-        previous_cursor = cursor
-        comments = parse_comments
-
-        if match(DO_KEYWORD)
-          block = parse_block
-          match(END_KEYWORD)
-        elsif match(OPENING_CURLY_BRACKET)
-          block = parse_block
-          match(CLOSING_CURLY_BRACKET)
-        else
-          @cursor = previous_cursor
-          buffer!
-          block = nil
-        end
-
-        {
-          call: {
-            name: name,
-            arguments: arguments,
-            block: block,
-            comments: comments
-          }.compact
-        }
-      end
-
-      private
-
-      def parse_block
-        comments = parse_comments
-
-        if match(PIPE)
-          parameters = []
-
-          parameters << (parse_keyword_parameter || parse_regular_parameter)
-
-          while match(COMMA) && !end_of_input?
-            parameters << (parse_keyword_parameter || parse_regular_parameter)
-          end
-
-          match(PIPE)
-
-          {
-            comments: comments,
-            parameters: parameters.compact,
-            body: parse_code
-          }.compact
-        else
-          { comments: comments, body: parse_code }.compact
-        end
-      end
-
-      def parse_keyword_argument
-        previous_cursor = cursor
-
-        comments_before = parse_comments
-        key = parse_subclass(::Code::Parser::Statement)
-        comments_after = parse_comments
-
-        if key && match(COLON) || match(EQUAL + GREATER)
-          default = parse_code
-          default = nil if default.empty?
-          {
-            comments_before: comments_before,
-            comments_after: comments_after,
-            default: default,
-            keyword: true,
-            statement: key
-          }.compact
-        else
-          @cursor = previous_cursor
-          buffer!
-          return
-        end
-      end
-
-      def parse_regular_argument
-        code = parse_code
-        return if code.empty?
-        code
-      end
-
-      def parse_keyword_parameter
-        previous_cursor = cursor
-
-        comments_before = parse_comments
-        name = parse_subclass(::Code::Parser::Name)
-        comments_after = parse_comments
-
-        if name && match(COLON) || match(EQUAL + GREATER)
-          default = parse_default
-
-          {
-            kind: :keyword,
-            name: name,
-            default: default,
-            comments_before: comments_before,
-            comments_after: comments_after
-          }.compact
-        else
-          @cursor = previous_cursor
-          buffer!
-          return
-        end
-      end
-
-      def parse_regular_parameter
-        previous_cursor = cursor
-        comments_before = parse_comments
-
-        if match(AMPERSAND)
-          kind = :block
-        elsif match(ASTERISK + ASTERISK)
-          kind = :keyword_splat
-        elsif match(ASTERISK)
-          kind = :regular_splat
-        else
-          kind = nil
-        end
-
-        name = parse_subclass(::Code::Parser::Name)
-
-        if name
-          comments_after = parse_comments
-
-          if match(EQUAL)
-            default = parse_default
-          else
-            default = nil
-          end
-
-          {
-            comments_before: comments_before,
-            comments_after: comments_after,
-            default: default,
-            name: name,
-            kind: kind
-          }.compact
-        else
-          @cursor = previous_cursor
-          buffer!
-          return
-        end
-      end
-
-      def parse_default
-        comments_before = parse_comments
-        statement = parse_subclass(::Code::Parser::BitwiseAnd)
-        comments_after = parse_comments
-
-        default = {
-          statement: statement,
-          comments_before: comments_before,
-          comments_after: comments_after
-        }.compact
-
-        default.empty? ? nil : default
-      end
-    end
-  end
-end

data/lib/code/parser/chained_call.rb

@@ -1,41 +0,0 @@
-class Code
-  class Parser
-    class ChainedCall < ::Code::Parser
-      def parse
-        left = parse_dictionnary
-        previous_cursor = cursor
-        comments_before = parse_comments
-
-        if left && match([DOT, COLON + COLON])
-          comments_after = parse_comments
-          right = parse_dictionnary
-          if right
-            chained_call = [{ left: left, right: right }]
-            while match([DOT, COLON + COLON]) && other_right = parse_dictionnary
-              chained_call << { right: other_right }
-            end
-            {
-              chained_call: {
-                calls: chained_call,
-                comments_before: comments_before,
-                comments_after: comments_after
-              }.compact
-            }
-          else
-            @cursor = previous_cursor
-            buffer!
-            left
-          end
-        else
-          @cursor = previous_cursor
-          buffer!
-          left
-        end
-      end
-
-      def parse_dictionnary
-        parse_subclass(::Code::Parser::Dictionnary)
-      end
-    end
-  end
-end

data/lib/code/parser/class.rb

@@ -1,55 +0,0 @@
-class Code
-  class Parser
-    class Class < ::Code::Parser
-      def parse
-        previous_cursor = cursor
-
-        if match(CLASS_KEYWORD)
-          first_comments = parse_comments
-
-          name = parse_subclass(::Code::Parser::Name)
-
-          if name
-            second_comments = parse_comments
-
-            if match(LESSER)
-              previous_cursor = cursor
-              third_comments = parse_comments
-              superclass = parse_subclass(::Code::Parser::Name)
-
-              if !superclass
-                @cursor = previous_cursor
-                buffer!
-                third_comments = nil
-              end
-            else
-              third_comments = nil
-              superclass = nil
-            end
-
-            body = parse_code
-
-            match(END_KEYWORD)
-
-            {
-              class: {
-                name: name,
-                superclass: superclass,
-                first_comments: first_comments,
-                second_comments: second_comments,
-                third_comments: third_comments,
-                body: body
-              }.compact
-            }
-          else
-            @cursor = previous_cursor
-            buffer!
-            parse_subclass(::Code::Parser::While)
-          end
-        else
-          parse_subclass(::Code::Parser::While)
-        end
-      end
-    end
-  end
-end

data/lib/code/parser/code.rb

@@ -1,20 +0,0 @@
-class Code
-  class Parser
-    class Code < ::Code::Parser
-      def parse
-        output = []
-
-        comments = parse_comments
-        output << { comments: comments } if comments
-
-        while code = parse_subclass(::Code::Parser::Statement)
-          output << code
-          comments = parse_comments
-          output << { comments: comments } if comments
-        end
-
-        output
-      end
-    end
-  end
-end

data/lib/code/parser/comments.rb

@@ -1,46 +0,0 @@
-class Code
-  class Parser
-    class Comments < ::Code::Parser
-      def initialize(input, whitespace: WHITESPACE, **kargs)
-        super(input, **kargs)
-        @whitespace = whitespace
-        @has_line_comments = whitespace.include?(NEWLINE)
-      end
-
-      def parse
-        comments = []
-
-        while next?(whitespace) || next?(SLASH + ASTERISK) ||
-                (line_comments? && (next?(SLASH + SLASH) || next?(HASH)))
-          consume while next?(whitespace)
-          buffer!
-
-          if match(SLASH + SLASH) || match(HASH)
-            consume while !next?(NEWLINE) && !end_of_input?
-            match(NEWLINE)
-            comments << buffer
-          end
-
-          consume while next?(whitespace)
-          buffer!
-
-          if match(SLASH + ASTERISK)
-            consume while !next?(ASTERISK + SLASH) && !end_of_input?
-            match(ASTERISK + SLASH)
-            comments << buffer
-          end
-        end
-
-        comments.empty? ? nil : comments
-      end
-    end
-
-    private
-
-    attr_reader :whitespace, :has_line_comments
-
-    def line_comments?
-      !!has_line_comments
-    end
-  end
-end

data/lib/code/parser/dictionnary.rb

@@ -1,52 +0,0 @@
-class Code
-  class Parser
-    class Dictionnary < ::Code::Parser
-      def parse
-        if match(OPENING_CURLY_BRACKET)
-          dictionnary = []
-
-          comments = parse_comments
-
-          dictionnary << parse_key_value
-
-          dictionnary << parse_key_value while match(COMMA) && !end_of_input?
-
-          match(CLOSING_CURLY_BRACKET)
-
-          { dictionnary: dictionnary.compact, comments: comments }.compact
-        else
-          parse_subclass(::Code::Parser::List)
-        end
-      end
-
-      def parse_key_value
-        previous_cursor = cursor
-
-        comments_before = parse_comments
-
-        key = parse_subclass(::Code::Parser::Statement)
-
-        comments_after = parse_comments
-
-        if key
-          if match(COLON) || match(EQUAL + GREATER)
-            value = parse_code
-          else
-            value = nil
-          end
-
-          {
-            key: key,
-            value: value,
-            comments_before: comments_before,
-            comments_after: comments_after
-          }.compact
-        else
-          @cursor = previous_cursor
-          buffer!
-          return
-        end
-      end
-    end
-  end
-end

data/lib/code/parser/equal.rb

@@ -1,68 +0,0 @@
-class Code
-  class Parser
-    class Equal < ::Code::Parser
-      def parse
-        previous_cursor = cursor
-
-        left = parse_left
-
-        comments_before = parse_comments
-
-        if left && operator = match(EQUALS)
-          comments_after = parse_comments
-
-          right = parse_subclass(::Code::Parser::Equal)
-
-          if right
-            {
-              equal: {
-                operator: operator,
-                left: left,
-                right: right,
-                comments_before: comments_before,
-                comments_after: comments_after
-              }.compact
-            }
-          else
-            @cursor = previous_cursor
-            buffer!
-            parse_next
-          end
-        else
-          @cursor = previous_cursor
-          buffer!
-          parse_next
-        end
-      end
-
-      private
-
-      def parse_next
-        parse_subclass(::Code::Parser::Rescue)
-      end
-
-      def parse_left
-        left = parse_subclass(::Code::Parser::Name)
-        return unless left
-
-        previous_cursor = cursor
-        comments_before = parse_comments
-
-        if match(DOT) || match(COLON + COLON)
-          right = parse_subclass(::Code::Parser::Name)
-          if right
-            { left: left, right: right }
-          else
-            @cursor = previous_cursor
-            buffer!
-            return
-          end
-        else
-          @cursor = previous_cursor
-          buffer!
-          left
-        end
-      end
-    end
-  end
-end

data/lib/code/parser/equality.rb

@@ -1,20 +0,0 @@
-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::GreaterThan
-        )
-      end
-    end
-  end
-end

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

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

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

data/lib/code/parser/function.rb

@@ -1,118 +0,0 @@
-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
-        name = parse_subclass(::Code::Parser::Name)
-        comments_after = parse_comments
-
-        if name && (match(COLON) || match(EQUAL + GREATER))
-          default = parse_code
-
-          {
-            kind: :keyword,
-            name: name,
-            default: default,
-            comments_before: comments_before,
-            comments_after: comments_after
-          }.compact
-        else
-          @cursor = previous_cursor
-          buffer!
-          return
-        end
-      end
-
-      def parse_regular_parameter
-        previous_cursor = cursor
-
-        comments_before = parse_comments
-
-        if match(AMPERSAND)
-          kind = :block
-        elsif match(ASTERISK + ASTERISK)
-          kind = :keyword_splat
-        elsif match(ASTERISK)
-          kind = :regular_splat
-        else
-          kind = nil
-        end
-
-        name = parse_subclass(::Code::Parser::Name)
-        comments_after = parse_comments
-
-        if name
-          if match(EQUAL)
-            default = parse_code
-          else
-            default = nil
-          end
-
-          {
-            kind: kind,
-            name: name,
-            default: default,
-            comments_before: comments_before,
-            comments_after: comments_after
-          }.compact
-        else
-          @cursor = previous_cursor
-          buffer!
-          return
-        end
-      end
-    end
-  end
-end

data/lib/code/parser/greater_than.rb

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

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