jievro-parser 0.4.0

data/lib/parser/grammar/statement/branch/if.treetop

@@ -0,0 +1,63 @@
+module Kauri
+  grammar StatementIf
+
+    rule statement_if
+      'if' ws1:whitespaces condition:statement_if_condition ws2:_ body:code_block ws3:_ else_block:statement_if_else? {
+        def tokens
+          tokens = []
+
+          tokens.push(T_IF)
+          tokens.concat(ws1.tokens)
+          tokens.concat(condition.tokens)
+          tokens.concat(ws2.tokens) unless ws2.text_value.empty?
+          tokens.concat(body.tokens)
+          tokens.concat(ws3.tokens) unless ws3.text_value.empty?
+          tokens.concat(else_block.tokens) unless else_block.text_value.empty?
+
+          tokens
+        end
+
+        def ast
+
+          ast = {
+            block_type: 'if-statement',
+            condition: condition.ast.first,
+            body: body.ast
+          }
+
+          unless else_block.text_value.empty?
+            ast[:else] = else_block.ast
+          end
+
+          [ast]
+        end
+      }
+    end
+
+    rule statement_if_condition
+      expression
+    end
+
+    rule statement_if_else
+      (
+        ('else' ws:whitespaces block:statement_if)
+        /
+        ('else' ws:_ block:code_block)
+      ) {
+        def tokens
+          tokens = []
+
+          tokens.push(T_ELSE)
+          tokens.concat(ws.tokens) unless ws.text_value.empty?
+          tokens.concat(block.tokens)
+
+          tokens
+        end
+
+        def ast
+          block.ast
+        end
+      }
+    end
+  end
+end

data/lib/parser/grammar/statement/loop/do_while.treetop

@@ -0,0 +1,32 @@
+module Kauri
+  grammar StatementDoWhile
+
+    rule statement_do_while
+      'do' ws1:_ body:code_block ws2:_ 'while' ws3:whitespaces test:expression {
+        def tokens
+          tokens = []
+
+          tokens.push(T_DO)
+          tokens.concat(ws1.tokens) unless ws1.text_value.empty?
+          tokens.concat(body.tokens)
+          tokens.concat(ws2.tokens) unless ws2.text_value.empty?
+          tokens.push(T_WHILE)
+          tokens.concat(ws3.tokens)
+          tokens.concat(test.tokens)
+
+          tokens
+        end
+
+        def ast
+          [
+            {
+              block_type: 'do-while-statement',
+              body: body.ast,
+              test: test.ast.first
+            }
+          ]
+        end
+      }
+    end
+  end
+end

data/lib/parser/grammar/statement/loop/for.treetop

@@ -0,0 +1,127 @@
+module Kauri
+  grammar StatementFor
+
+    rule statement_for
+      'for' ws1:_ for_block:(for_block_without_parentheses / for_block_with_parentheses) ws2:_ for_body {
+        def tokens
+          tokens = []
+
+          tokens.push(T_FOR)
+          tokens.concat(ws1.tokens) unless ws1.text_value.empty?
+          tokens.concat(for_block.tokens)
+          tokens.concat(ws2.tokens) unless ws2.text_value.empty?
+          tokens.concat(for_body.tokens)
+
+          tokens
+        end
+
+        def ast
+
+          ast_for_block = for_block.ast
+
+          init = ast_for_block[:init]
+          test = ast_for_block[:test]
+          update = ast_for_block[:update]
+          body = for_body.ast
+
+          ast = {
+            block_type: 'for-statement',
+            init: init
+          }
+
+          if test
+            ast[:test] = test
+          end
+
+          if update
+            ast[:update] = update
+          end
+
+          ast[:body] = body
+
+          [ast]
+        end
+      }
+    end
+
+    rule for_block_without_parentheses
+      for_block
+    end
+
+    rule for_block_with_parentheses
+      '(' ws1:_ for_block:for_block ws2:_ ')' {
+        def tokens
+          tokens = []
+
+          tokens.push(T_OPEN_ROUND_BRACKET)
+          tokens.concat(ws1.tokens) unless ws1.text_value.empty?
+          tokens.concat(for_block.tokens)
+          tokens.concat(ws2.tokens) unless ws2.text_value.empty?
+          tokens.push(T_CLOSE_ROUND_BRACKET)
+
+          tokens
+        end
+
+        def ast
+          for_block.ast
+        end
+      }
+    end
+
+    rule for_block
+      for_init:for_init? ws1:_ ';' ws2:_ for_test:for_test? ws3:_ ';' ws4:_ for_update:for_update? {
+        def tokens
+          tokens = []
+
+          tokens.concat(for_init.tokens) unless for_init.text_value.empty?
+          tokens.concat(ws1.tokens) unless ws1.text_value.empty?
+          tokens.push(T_SEMICOLON)
+          tokens.concat(ws2.tokens) unless ws2.text_value.empty?
+          tokens.concat(for_test.tokens) unless for_test.text_value.empty?
+          tokens.concat(ws3.tokens) unless ws3.text_value.empty?
+          tokens.push(T_SEMICOLON)
+          tokens.concat(ws4.tokens) unless ws4.text_value.empty?
+          tokens.concat(for_update.tokens) unless for_update.text_value.empty?
+
+          tokens
+        end
+
+        def ast
+          ast = {}
+
+          unless for_init.text_value.empty?
+            ast[:init] = for_init.ast
+          else
+            ast[:init] = []
+          end
+
+          unless for_test.text_value.empty?
+            ast[:test] = for_test.ast.first
+          end
+
+          unless for_update.text_value.empty?
+            ast[:update] = for_update.ast
+          end
+
+          ast
+        end
+       }
+    end
+
+    rule for_init
+      variable_declaration / expression_list
+    end
+
+    rule for_test
+      expression
+    end
+
+    rule for_update
+      expression_list
+    end
+
+    rule for_body
+      code_block
+    end
+  end
+end

data/lib/parser/grammar/statement/loop/for_in.treetop

@@ -0,0 +1,35 @@
+module Kauri
+  grammar StatementForIn
+
+    rule statement_for_in
+      'for' ws1:whitespaces iterator:pattern ws2:whitespaces 'in' ws3:whitespaces collection:expression ws4:_ body:code_block {
+        def tokens
+          tokens = []
+
+          tokens.push(T_FOR)
+          tokens.concat(ws1.tokens)
+          tokens.concat(iterator.tokens)
+          tokens.concat(ws2.tokens)
+          tokens.push(T_IN)
+          tokens.concat(ws3.tokens)
+          tokens.concat(collection.tokens)
+          tokens.concat(ws4.tokens) unless ws4.text_value.empty?
+          tokens.concat(body.tokens)
+
+          tokens
+        end
+
+        def ast
+          [
+            {
+              block_type: 'for-in-statement',
+              iterator: iterator.ast.first,
+              collection: collection.ast.first,
+              body: body.ast
+            }
+          ]
+        end
+      }
+    end
+  end
+end

data/lib/parser/grammar/statement/loop/loop.treetop

@@ -0,0 +1,22 @@
+require 'parser/grammar/statement/loop/for'
+require 'parser/grammar/statement/loop/for_in'
+require 'parser/grammar/statement/loop/while'
+require 'parser/grammar/statement/loop/do_while'
+
+module Kauri
+  module Grammar
+    module Statement
+      grammar Loop
+
+        include Kauri::StatementFor
+        include Kauri::StatementForIn
+        include Kauri::StatementWhile
+        include Kauri::StatementDoWhile
+
+        rule statement_loop
+          statement_for_in / statement_for / statement_while / statement_do_while
+        end
+      end
+    end
+  end
+end

data/lib/parser/grammar/statement/loop/while.treetop

@@ -0,0 +1,34 @@
+module Kauri
+  grammar StatementWhile
+
+    rule statement_while
+      'while' ws1:whitespaces condition:statement_while_condition ws2:_ body:code_block {
+        def tokens
+          tokens = []
+
+          tokens.push(T_WHILE)
+          tokens.concat(ws1.tokens)
+          tokens.concat(condition.tokens)
+          tokens.concat(ws2.tokens) unless ws2.text_value.empty?
+          tokens.concat(body.tokens)
+
+          tokens
+        end
+
+        def ast
+          [
+            {
+              block_type: 'while-statement',
+              condition: condition.ast.first,
+              body: body.ast
+            }
+          ]
+        end
+      }
+    end
+
+    rule statement_while_condition
+      expression
+    end
+  end
+end

data/lib/parser/grammar/statement/statement.treetop

@@ -0,0 +1,97 @@
+require 'parser/grammar/statement/loop/loop'
+require 'parser/grammar/statement/branch/branch'
+
+module Kauri
+  grammar Statement
+
+    include Kauri::Grammar::Statement::Loop
+    include Kauri::Grammar::Statement::Branch
+
+    rule statement
+      statement_loop / statement_branch / expression_statement / declaration_statement
+    end
+
+    rule statement_list
+      statement+ {
+        def tokens
+          tokens = []
+
+          elements.each { |e|
+            tokens.concat(e.tokens)
+          }
+
+          tokens
+        end
+
+        def ast
+          ast = []
+
+          elements.each { |e|
+            ast.concat(e.ast)
+          }
+
+          ast
+        end
+      }
+    end
+
+    rule expression_statement
+      expression:expression ws:_ semicolon:semicolon? {
+        def tokens
+          tokens = []
+
+          tokens.concat(expression.tokens)
+
+          unless ws.text_value.empty?
+            tokens.concat(ws.tokens)
+          end
+
+          unless semicolon.text_value.empty?
+            tokens.concat(semicolon.tokens)
+          end
+
+          tokens
+        end
+
+        def ast
+          expression.ast
+        end
+      }
+    end
+
+    rule declaration_statement
+      declaration:declaration ws:_ semicolon:semicolon? {
+        def tokens
+          tokens = []
+
+          tokens.concat(declaration.tokens)
+
+          unless ws.text_value.empty?
+            tokens.concat(ws.tokens)
+          end
+
+          unless semicolon.text_value.empty?
+            tokens.concat(semicolon.tokens)
+          end
+
+          tokens
+        end
+
+        def ast
+          declaration.ast
+        end
+      }
+    end
+
+    rule semicolon
+      ';' {
+        def tokens
+          [{
+            type: 'T_SEMICOLON',
+            value: ';'
+          }]
+        end
+      }
+    end
+  end
+end

data/lib/parser/grammar/type/type.treetop

@@ -0,0 +1,18 @@
+require 'parser/grammar/type/type_identifier'
+require 'parser/grammar/type/type_array'
+require 'parser/grammar/type/type_dictionary'
+require 'parser/grammar/type/type_annotation'
+
+module Kauri
+  grammar Type
+
+    include Kauri::TypeIdentifier
+    include Kauri::TypeArray
+    include Kauri::TypeDictionary
+    include Kauri::TypeAnnotation
+
+    rule type
+      type_identifier / type_dictionary / type_array
+    end
+  end
+end

data/lib/parser/grammar/type/type_annotation.treetop

@@ -0,0 +1,29 @@
+module Kauri
+  grammar TypeAnnotation
+
+    rule type_annotation
+      ':' ws:_ type {
+        def tokens
+          tokens = []
+
+          tokens.push({
+            type: 'T_COLON',
+            value: ':',
+          })
+
+          unless ws.text_value.empty?
+            tokens.concat(ws.tokens)
+          end
+
+          tokens.concat(type.tokens)
+
+          tokens
+        end
+
+        def ast
+          type.ast
+        end
+      }
+    end
+  end
+end

data/lib/parser/grammar/type/type_array.treetop

@@ -0,0 +1,43 @@
+module Kauri
+  grammar TypeArray
+
+    rule type_array
+      '[' ws1:_ type:type ws2:_ ']' {
+        def tokens
+          tokens = []
+
+          tokens.push({
+            type: 'T_OPEN_SQUARE_BRACKET',
+            value: '[',
+          })
+
+          unless ws1.text_value.empty?
+            tokens.concat(ws1.tokens)
+          end
+
+          tokens.concat(type.tokens)
+
+          unless ws2.text_value.empty?
+            tokens.concat(ws2.tokens)
+          end
+
+          tokens.push({
+            type: 'T_CLOSE_SQUARE_BRACKET',
+            value: ']',
+          })
+
+          tokens
+        end
+
+        def ast
+          [
+            {
+              block_type: 'array',
+              type: type.ast.first
+            }
+          ]
+        end
+      }
+    end
+  end
+end

data/lib/parser/grammar/type/type_dictionary.treetop

@@ -0,0 +1,59 @@
+module Kauri
+  grammar TypeDictionary
+
+    rule type_dictionary
+      '[' ws1:_ key_type:type ws2:_ ':' ws3:_ value_type:type ws4:_ ']' {
+        def tokens
+          tokens = []
+
+          tokens.push({
+            type: 'T_OPEN_SQUARE_BRACKET',
+            value: '[',
+          })
+
+          unless ws1.text_value.empty?
+            tokens.concat(ws1.tokens)
+          end
+
+          tokens.concat(key_type.tokens)
+
+          unless ws2.text_value.empty?
+            tokens.concat(ws2.tokens)
+          end
+
+          tokens.push({
+            type: 'T_COLON',
+            value: ':',
+          })
+
+          unless ws3.text_value.empty?
+            tokens.concat(ws3.tokens)
+          end
+
+          tokens.concat(value_type.tokens)
+
+          unless ws4.text_value.empty?
+            tokens.concat(ws4.tokens)
+          end
+
+          tokens.push({
+            type: 'T_CLOSE_SQUARE_BRACKET',
+            value: ']',
+          })
+
+          tokens
+        end
+
+        def ast
+          [
+            {
+              block_type: 'dictionary',
+              key_type: key_type.ast.first,
+              value_type: value_type.ast.first
+            }
+          ]
+        end
+      }
+    end
+  end
+end

data/lib/parser/grammar/type/type_identifier.treetop

@@ -0,0 +1,39 @@
+module Kauri
+  grammar TypeIdentifier
+
+    rule type_identifier
+      type_name:type_name ws:_ generic_argument_clause:generic_argument_clause? {
+        def tokens
+
+          tokens = []
+
+          tokens.concat(type_name.tokens)
+
+          unless ws.text_value.empty?
+            tokens.concat(ws.tokens)
+          end
+
+          unless generic_argument_clause.text_value.empty?
+            tokens.concat(generic_argument_clause.tokens)
+          end
+
+          tokens
+        end
+        def ast
+
+          ast = type_name.ast
+
+          unless generic_argument_clause.text_value.empty?
+            ast.first[:parameters] = generic_argument_clause.ast
+          end
+
+          ast
+        end
+      }
+    end
+
+    rule type_name
+      identifier
+    end
+  end
+end

data/lib/parser/grammar/whitespace.treetop

@@ -0,0 +1,40 @@
+module Kauri
+  grammar Whitespace
+
+    rule _
+      whitespaces?
+    end
+
+    rule whitespaces
+      whitespace+ {
+        def tokens
+          [
+            {
+              type: 'T_WHITESPACES',
+              value: text_value
+            }
+          ]
+        end
+        def ast
+          []
+        end
+      }
+    end
+
+    rule whitespace
+      space / tab / line_break
+    end
+
+    rule space
+      [ ]
+    end
+
+    rule tab
+      [\t]
+    end
+
+    rule line_break
+      [\n]
+    end
+  end
+end

data/lib/parser/grammar/wildcard.treetop

@@ -0,0 +1,25 @@
+module Kauri
+  grammar Wildcard
+
+    rule wildcard
+      '_' {
+        def tokens
+          [
+            {
+              type: 'T_WILDCARD',
+              value: '_'
+            }
+          ]
+        end
+
+        def ast
+          [
+            {
+              block_type: 'wildcard'
+            }
+          ]
+        end
+      }
+    end
+  end
+end

data/lib/parser/parse_result.rb

@@ -0,0 +1,17 @@
+module Jievro
+  class ParseResult
+
+    def initialize(tokens, ast)
+      @tokens = tokens
+      @ast = ast
+    end
+
+    def tokens
+      @tokens
+    end
+
+    def ast
+      @ast
+    end
+  end
+end