jievro-parser 0.8.0 → 0.9.0

data/lib/jievro/parser/grammar/declaration/initializer_declaration.treetop

@@ -0,0 +1,16 @@
+module Jievro
+  grammar InitializerDeclaration
+
+    rule initializer_head
+      'init' {
+        def tokens
+          [T_INIT]
+        end
+
+        def ast
+          []
+        end
+      }
+    end
+  end
+end

data/lib/jievro/parser/grammar/declaration/protocol_declaration.treetop

@@ -0,0 +1,164 @@
+module Jievro
+  grammar ProtocolDeclaration
+
+    rule protocol_declaration
+      'protocol' ws1:whitespaces identifier:identifier ws2:_ inheritances:type_inheritance_clause? ws3:_ '{' ws4:_ declarations:protocol_member_declarations? ws5:_ '}' {
+        def tokens
+          tokens = []
+
+          tokens.push(T_PROTOCOL)
+          tokens.concat(ws1.tokens)
+          tokens.concat(identifier.tokens)
+          tokens.concat(ws2.tokens) unless ws2.text_value.empty?
+          tokens.concat(inheritances.tokens) unless inheritances.text_value.empty?
+          tokens.concat(ws3.tokens) unless ws3.text_value.empty?
+          tokens.push(T_OPEN_CURLY_BRACKET)
+          tokens.concat(ws4.tokens) unless ws4.text_value.empty?
+          tokens.concat(declarations.tokens) unless declarations.text_value.empty?
+          tokens.concat(ws5.tokens) unless ws5.text_value.empty?
+          tokens.push(T_CLOSE_CURLY_BRACKET)
+
+          tokens
+        end
+
+        def ast
+          if inheritances.text_value.empty?
+            inhers = []
+          else
+            inhers = inheritances.ast
+          end
+
+          if declarations.text_value.empty?
+            decls = []
+          else
+            decls = declarations.ast
+          end
+
+          [
+            {
+              __type: 'protocol-declaration',
+              name: identifier.ast.first,
+              inheritances: inhers,
+              declarations: decls
+            }
+          ]
+        end
+      }
+    end
+
+    rule protocol_member_declarations
+      (ws1:_ declaration:protocol_member_declaration ws2:_)+ {
+        def tokens
+          tokens = []
+
+          elements.each { |e|
+            tokens.concat(e.ws1.tokens) unless e.ws1.text_value.empty?
+            tokens.concat(e.declaration.tokens)
+            tokens.concat(e.ws2.tokens) unless e.ws2.text_value.empty?
+          }
+
+          tokens
+        end
+
+        def ast
+          ast = []
+
+          elements.each { |e|
+            ast.concat(e.declaration.ast)
+          }
+
+          ast
+        end
+      }
+    end
+
+    rule protocol_member_declaration
+      protocol_property_declaration
+      /
+      protocol_method_declaration
+      /
+      protocol_initializer_declaration
+    end
+
+    rule protocol_property_declaration
+      head:variable_declaration_head ws1:_ name:variable_name ws2:_ type:type_annotation ws3:_ accessors:getter_setter_keyword_block {
+        def tokens
+          tokens = []
+
+          tokens.concat(head.tokens)
+          tokens.concat(ws1.tokens) unless ws1.text_value.empty?
+          tokens.concat(name.tokens)
+          tokens.concat(ws2.tokens) unless ws2.text_value.empty?
+          tokens.concat(type.tokens)
+          tokens.concat(ws3.tokens) unless ws3.text_value.empty?
+          tokens.concat(accessors.tokens)
+
+          tokens
+        end
+
+        def ast
+          [
+            {
+              __type: 'property-declaration',
+              name: name.ast.first,
+              type: type.ast.first,
+              accessors: accessors.ast
+            }
+          ]
+        end
+      }
+    end
+
+    rule protocol_method_declaration
+      head:function_head ws1:whitespaces name:function_name ws2:_ signature:function_signature {
+        def tokens
+          tokens = []
+
+          tokens.concat(head.tokens)
+          tokens.concat(ws1.tokens)
+          tokens.concat(name.tokens)
+          tokens.concat(ws2.tokens) unless ws2.text_value.empty?
+          tokens.concat(signature.tokens)
+
+          tokens
+        end
+
+        def ast
+          sign = signature.ast
+
+          [
+            {
+              __type: 'function-declaration',
+              name: name.ast.first,
+              parameters: sign[:parameters],
+              return_type: sign[:return_type]
+            }
+          ]
+        end
+      }
+    end
+
+    rule protocol_initializer_declaration
+      head:initializer_head ws:_ parameter_clause:parameter_clause {
+        def tokens
+          tokens = []
+
+          tokens.concat(head.tokens)
+          tokens.concat(ws.tokens) unless ws.text_value.empty?
+          tokens.concat(parameter_clause.tokens)
+
+          tokens
+        end
+
+        def ast
+          [
+            {
+              __type: 'init-declaration',
+              parameters: parameter_clause.ast
+            }
+          ]
+        end
+      }
+    end
+  end
+end

data/lib/jievro/parser/grammar/declaration/struct_declaration.treetop

@@ -0,0 +1,49 @@
+module Jievro
+  grammar StructDeclaration
+
+    rule struct_declaration
+      'struct' ws1:whitespaces identifier:identifier ws2:_ inheritances:type_inheritance_clause? ws3:_ '{' ws4:_ declarations:declarations? ws5:_ '}' {
+        def tokens
+          tokens = []
+
+          tokens.push(T_STRUCT)
+          tokens.concat(ws1.tokens)
+          tokens.concat(identifier.tokens)
+          tokens.concat(ws2.tokens) unless ws2.text_value.empty?
+          tokens.concat(inheritances.tokens) unless inheritances.text_value.empty?
+          tokens.concat(ws3.tokens) unless ws3.text_value.empty?
+          tokens.push(T_OPEN_CURLY_BRACKET)
+          tokens.concat(ws4.tokens) unless ws4.text_value.empty?
+          tokens.concat(declarations.tokens) unless declarations.text_value.empty?
+          tokens.concat(ws5.tokens) unless ws5.text_value.empty?
+          tokens.push(T_CLOSE_CURLY_BRACKET)
+
+          tokens
+        end
+
+        def ast
+          if declarations.text_value.empty?
+            decls = []
+          else
+            decls = declarations.ast
+          end
+
+          if inheritances.text_value.empty?
+            inhers = []
+          else
+            inhers = inheritances.ast
+          end
+
+          [
+            {
+              __type: 'struct-declaration',
+              name: identifier.ast.first,
+              inheritances: inhers,
+              declarations: decls
+            }
+          ]
+        end
+      }
+    end
+  end
+end

data/lib/jievro/parser/grammar/declaration/typealias_declaration.treetop

@@ -0,0 +1,64 @@
+module Jievro
+  grammar TypealiasDeclaration
+
+    rule typealias_declaration
+      head:typealias_head ws:_ typealias:typealias_assignment {
+        def tokens
+          tokens = []
+
+          tokens.concat(head.tokens)
+          tokens.concat(ws.tokens) unless ws.text_value.empty?
+          tokens.concat(typealias.tokens)
+
+          tokens
+        end
+
+        def ast
+          [
+            {
+              __type: "typealias-declaration",
+              name: head.ast.first,
+              type: typealias.ast.first
+            }
+          ]
+        end
+      }
+    end
+
+    rule typealias_head
+      'typealias' ws:_ identifier {
+        def tokens
+          tokens = []
+
+          tokens.push(T_TYPEALIAS)
+          tokens.concat(ws.tokens) unless ws.text_value.empty?
+          tokens.concat(identifier.tokens)
+
+          tokens
+        end
+
+        def ast
+          identifier.ast
+        end
+      }
+    end
+
+    rule typealias_assignment
+      '=' ws:_ type {
+        def tokens
+          tokens = []
+
+          tokens.push(T_OPERATOR('='))
+          tokens.concat(ws.tokens) unless ws.text_value.empty?
+          tokens.concat(type.tokens)
+
+          tokens
+        end
+
+        def ast
+          type.ast
+        end
+      }
+    end
+  end
+end

data/lib/jievro/parser/grammar/declaration/variable_declaration.treetop

@@ -1,17 +1,12 @@
-module Kauri
+module Jievro
   grammar VariableDeclaration
 
     rule variable_declaration
-      'var' whitespaces:whitespaces pattern_initializer_list:pattern_initializer_list {
+      head:variable_declaration_head whitespaces:whitespaces pattern_initializer_list:pattern_initializer_list {
         def tokens
-
           tokens = []
 
-          tokens.push({
-            type: 'T_VAR',
-            value: 'var'
-          })
-
+          tokens.concat(head.tokens)
           tokens.concat(whitespaces.tokens)
           tokens.concat(pattern_initializer_list.tokens)
 
@@ -19,7 +14,6 @@ module Kauri
         end
 
         def ast
-
           ast = []
 
           pattern_initializer_list.ast.each { |e|
@@ -34,5 +28,115 @@ module Kauri
         end
       }
     end
+
+    rule variable_declaration_head
+      'var' {
+        def tokens
+          [T_VAR]
+        end
+      }
+    end
+
+    rule variable_name
+      identifier
+    end
+
+    rule getter_setter_keyword_block
+      '{' ws1:_ block:(getter_setter_keyword_clause / setter_getter_keyword_clause / getter_keyword_clause / setter_keyword_clause) ws2:_ '}' {
+        def tokens
+          tokens = []
+
+          tokens.push(T_OPEN_CURLY_BRACKET)
+          tokens.concat(ws1.tokens) unless ws1.text_value.empty?
+          tokens.concat(block.tokens)
+          tokens.concat(ws2.tokens) unless ws2.text_value.empty?
+          tokens.push(T_CLOSE_CURLY_BRACKET)
+
+          tokens
+        end
+
+        def ast
+          block.ast
+        end
+      }
+    end
+
+    rule getter_setter_keyword_clause
+      getter:getter_keyword_clause ws:whitespaces setter:setter_keyword_clause {
+        def tokens
+          tokens = []
+
+          tokens.concat(getter.tokens)
+          tokens.concat(ws.tokens)
+          tokens.concat(setter.tokens)
+
+          tokens
+        end
+
+        def ast
+          ast = []
+
+          ast.concat(getter.ast)
+          ast.concat(setter.ast)
+
+          ast
+        end
+      }
+    end
+
+    rule setter_getter_keyword_clause
+      setter:setter_keyword_clause ws:whitespaces getter:getter_keyword_clause {
+        def tokens
+          tokens = []
+
+          tokens.concat(setter.tokens)
+          tokens.concat(ws.tokens)
+          tokens.concat(getter.tokens)
+
+          tokens
+        end
+
+        def ast
+          ast = []
+
+          ast.concat(setter.ast)
+          ast.concat(getter.ast)
+
+          ast
+        end
+      }
+    end
+
+    rule getter_keyword_clause
+      'get' {
+        def tokens
+          [T_GET]
+        end
+
+        def ast
+          [
+            {
+              __type: 'getter-accessor'
+            }
+          ]
+        end
+      }
+    end
+
+    rule setter_keyword_clause
+      'set' {
+        def tokens
+          [T_SET]
+        end
+
+        def ast
+          [
+            {
+              __type: 'setter-accessor'
+            }
+          ]
+        end
+      }
+    end
   end
 end

data/lib/jievro/parser/grammar/expression/binary_expression.treetop

@@ -1,37 +1,28 @@
 require 'jievro/parser/tools/shunting_yard'
 
-module Kauri
+module Jievro
   grammar BinaryExpression
 
     rule binary_expression
       left:infix_operation_chain ws:_ right:primary_expression {
         def tokens
-
           tokens = []
 
           tokens.concat(left.tokens)
-
-          unless ws.text_value.empty?
-            tokens.concat(ws.tokens)
-          end
-
+          tokens.concat(ws.tokens) unless ws.text_value.empty?
           tokens.concat(right.tokens)
 
           tokens
         end
 
         def ast
-
           sy = Jievro::Parser::Tools::ShuntingYard.new
-
           flatten_ast = []
 
           flatten_ast.concat(left.flatten_ast)
           flatten_ast.push(right.ast.first)
 
-          ast = sy.generate_ast(flatten_ast)
-
-          ast
+          sy.generate_ast(flatten_ast)
         end
       }
     end
@@ -42,18 +33,10 @@ module Kauri
           tokens = []
 
           elements.each { |e|
-
             tokens.concat(e.primary.tokens)
-
-            unless e.ws1.text_value.empty?
-              tokens.concat(e.ws1.tokens)
-            end
-
+            tokens.concat(e.ws1.tokens) unless e.ws1.text_value.empty?
             tokens.concat(e.operator.tokens)
-
-            unless e.ws2.text_value.empty?
-              tokens.concat(e.ws2.tokens)
-            end
+            tokens.concat(e.ws2.tokens) unless e.ws2.text_value.empty?
           }
 
           tokens