jievro-parser 0.8.0 → 0.9.0

data/lib/jievro/parser/grammar/generics/generics.treetop

@@ -1,9 +1,9 @@
 require 'jievro/parser/grammar/generics/generic_argument_clause'
 
-module Kauri
+module Jievro
   grammar Generics
 
-    include Kauri::GenericArgumentClause
+    include Jievro::GenericArgumentClause
 
   end
 end

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

@@ -10,27 +10,27 @@ require 'jievro/parser/grammar/code_block'
 require 'jievro/parser/grammar/pattern/pattern'
 require 'jievro/parser/grammar/wildcard'
 require 'jievro/parser/grammar/operator'
-
 require 'jievro/parser/tools/tokens'
 
 module Jievro
   grammar Swift
 
-    include Kauri::Whitespace
-    include Kauri::Literal
-    include Kauri::Identifier
-    include Kauri::Declaration
-    include Kauri::Statement
-    include Kauri::Expression
-    include Kauri::Generics
-    include Kauri::Type
-    include Kauri::CodeBlock
-    include Kauri::Pattern
-    include Kauri::Wildcard
-    include Kauri::Operator
+    include Jievro::Whitespace
+    include Jievro::Literal
+    include Jievro::Identifier
+    include Jievro::Declaration
+    include Jievro::Statement
+    include Jievro::Expression
+    include Jievro::Generics
+    include Jievro::Type
+    include Jievro::CodeBlock
+    include Jievro::Pattern
+    include Jievro::Wildcard
+    include Jievro::Operator
 
     rule root
-      (
+      ws1:_
+      program:(
         declaration:declaration
         /
         statement:statement
@@ -40,31 +40,38 @@ module Jievro
         identifier:identifier
         /
         whitespaces:whitespaces
-      ) {
+      )*
+      ws2:_
+      {
         def tokens
-          unless elements.any?
-            tokens = []
-          else
-            tokens = elements[0].tokens
+          tokens = []
+
+          tokens.concat(ws1.tokens) unless ws1.text_value.empty?
+
+          unless program.text_value.empty?
+            program.elements.each do |e|
+              tokens.concat(e.elements.first.tokens)
+            end
           end
 
+          tokens.concat(ws2.tokens) unless ws2.text_value.empty?
+
           tokens
         end
 
         def ast
           body = []
 
-          if elements.length
-            e = elements[0]
-            if e.respond_to?(:ast)
-              body = e.ast
+          unless program.text_value.empty?
+            program.elements.each do |e|
+              body.concat(e.elements.first.ast)
             end
-
-            {
-              __type: 'program',
-              body: body
-            }
           end
+
+          {
+            __type: 'program',
+            body: body
+          }
         end
       }
     end

data/lib/jievro/parser/grammar/identifier.treetop

@@ -1,9 +1,9 @@
 require 'jievro/parser/grammar/implicit_parameter_name'
 
-module Kauri
+module Jievro
   grammar Identifier
 
-    include Kauri::ImplicitParameterName
+    include Jievro::ImplicitParameterName
 
     rule identifier
       implicit_parameter_name / backticked_identifier / regular_identifier

data/lib/jievro/parser/grammar/implicit_parameter_name.treetop

@@ -1,4 +1,4 @@
-module Kauri
+module Jievro
   grammar ImplicitParameterName
 
     rule implicit_parameter_name

data/lib/jievro/parser/grammar/literal/literal.treetop

@@ -5,37 +5,38 @@ require 'jievro/parser/grammar/literal/literal_string'
 require 'jievro/parser/grammar/literal/literal_array'
 require 'jievro/parser/grammar/literal/literal_dictionary'
 
-module Kauri
+module Jievro
   grammar Literal
 
-    include Kauri::LiteralNil
-    include Kauri::LiteralBoolean
-    include Kauri::LiteralNumeric
-    include Kauri::LiteralString
-    include Kauri::LiteralArray
-    include Kauri::LiteralDictionary
+    include Jievro::LiteralNil
+    include Jievro::LiteralBoolean
+    include Jievro::LiteralNumeric
+    include Jievro::LiteralString
+    include Jievro::LiteralArray
+    include Jievro::LiteralDictionary
 
     rule literal
-      (literal_nil / literal_boolean / literal_numeric / literal_string / literal_array / literal_dictionary) {
+      (
+        literal_nil
+        /
+        literal_boolean
+        /
+        literal_numeric
+        /
+        literal_string
+        /
+        literal_array
+        /
+        literal_dictionary
+      ) {
         def ast
+          return super if defined?(super)
+          return [] if elements.nil?
+          return [] unless elements.any?
 
-          if defined?(super)
-            return super
-          end
+          e = elements.first
 
-          if elements.nil?
-            return []
-          end
-
-          unless elements.any?
-            return []
-          end
-
-          first_element = elements.first
-
-          if first_element.respond_to?(:ast)
-            return first_element.ast
-          end
+          return e.ast if e.respond_to?(:ast)
 
           []
         end

data/lib/jievro/parser/grammar/literal/literal_array.treetop

@@ -1,4 +1,4 @@
-module Kauri
+module Jievro
   grammar LiteralArray
 
     rule literal_array
@@ -6,36 +6,19 @@ module Kauri
         def tokens
           tokens = []
 
-          tokens.push({
-            type: 'T_OPEN_SQUARE_BRACKET',
-            value: '['
-          })
-
-          unless ws1.text_value.empty?
-            tokens.concat(ws1.tokens)
-          end
-
-          unless items.text_value.empty?
-            tokens.concat(items.tokens)
-          end
-
-          unless ws2.text_value.empty?
-            tokens.concat(ws2.tokens)
-          end
-
-          tokens.push({
-            type: 'T_CLOSE_SQUARE_BRACKET',
-            value: ']'
-          })
+          tokens.push(T_OPEN_SQUARE_BRACKET)
+          tokens.concat(ws1.tokens) unless ws1.text_value.empty?
+          tokens.concat(items.tokens) unless items.text_value.empty?
+          tokens.concat(ws2.tokens) unless ws2.text_value.empty?
+          tokens.push(T_CLOSE_SQUARE_BRACKET)
 
           tokens
         end
 
         def ast
-
-          values = []
-
-          unless items.text_value.empty?
+          if items.text_value.empty?
+            values = []
+          else
             values = items.ast
           end
 
@@ -56,21 +39,10 @@ module Kauri
 
           unless head.text_value.empty?
             head.elements.each { |e|
-
               tokens.concat(e.expression.tokens)
-
-              unless e.ws1.text_value.empty?
-                tokens.concat(e.ws1.tokens)
-              end
-
-              tokens.push({
-                type: 'T_COMMA',
-                value: ','
-              })
-
-              unless e.ws2.text_value.empty?
-                tokens.concat(e.ws2.tokens)
-              end
+              tokens.concat(e.ws1.tokens) unless e.ws1.text_value.empty?
+              tokens.push(T_COMMA)
+              tokens.concat(e.ws2.tokens) unless e.ws2.text_value.empty?
             }
           end
 

data/lib/jievro/parser/grammar/literal/literal_boolean.treetop

@@ -1,4 +1,4 @@
-module Kauri
+module Jievro
   grammar LiteralBoolean
 
     rule literal_boolean
@@ -8,13 +8,9 @@ module Kauri
     rule literal_true
       'true' {
         def tokens
-          [
-            {
-              type: 'T_TRUE',
-              value: text_value
-            }
-          ]
+          [T_TRUE]
         end
+
         def ast
           [
             {
@@ -29,13 +25,9 @@ module Kauri
     rule literal_false
       'false' {
         def tokens
-          [
-            {
-              type: 'T_FALSE',
-              value: text_value
-            }
-          ]
+          [T_FALSE]
         end
+
         def ast
           [
             {

data/lib/jievro/parser/grammar/literal/literal_decimal_floating_point.treetop

@@ -1,6 +1,4 @@
-require 'jievro/parser/tools/converter/converter'
-
-module Kauri
+module Jievro
   grammar LiteralDecimalFloatingPoint
 
     rule literal_decimal_floating_point
@@ -13,16 +11,12 @@ module Kauri
       ) {
         def tokens
           [
-            {
-              type: 'T_LITERAL_FLOATING_POINT_DECIMAL',
-              value: text_value
-            }
+            T_LITERAL_FLOATING_POINT_DECIMAL(text_value)
           ]
         end
 
         def ast
-
-          converter = Kauri::Tools::Converter::DecimalFloatStringToFloatConverter.new
+          converter = Jievro::Tools::Converter::DecimalFloatStringToFloatConverter.new
 
           [
             {

data/lib/jievro/parser/grammar/literal/literal_dictionary.treetop

@@ -1,4 +1,4 @@
-module Kauri
+module Jievro
   grammar LiteralDictionary
 
     rule literal_dictionary
@@ -6,25 +6,11 @@ module Kauri
         def tokens
           tokens = []
 
-          tokens.push({
-            type: 'T_OPEN_SQUARE_BRACKET',
-            value: '['
-          })
-
-          unless ws1.text_value.empty?
-            tokens.concat(ws1.tokens)
-          end
-
+          tokens.push(T_OPEN_SQUARE_BRACKET)
+          tokens.concat(ws1.tokens) unless ws1.text_value.empty?
           tokens.concat(content.tokens)
-
-          unless ws2.text_value.empty?
-            tokens.concat(ws2.tokens)
-          end
-
-          tokens.push({
-            type: 'T_CLOSE_SQUARE_BRACKET',
-            value: ']'
-          })
+          tokens.concat(ws2.tokens) unless ws2.text_value.empty?
+          tokens.push(T_CLOSE_SQUARE_BRACKET)
 
           tokens
         end
@@ -38,28 +24,25 @@ module Kauri
     rule literal_dictionary_content
       (items:literal_dictionary_items / ':') {
         def tokens
-
           if defined? items
             tokens = items.tokens
           else
-            tokens = [{
-              type: 'T_COLON',
-              value: ':'
-            }]
+            tokens = [T_COLON]
           end
 
           tokens
         end
 
         def ast
-
           if defined? items
             ast = items.ast
           else
-            ast = [{
-              __type: 'literal-dictionary',
-              pairs: []
-            }]
+            ast = [
+              {
+                __type: 'literal-dictionary',
+                pairs: []
+              }
+            ]
           end
 
           ast
@@ -73,20 +56,9 @@ module Kauri
           tokens = []
 
           tokens.concat(key.tokens)
-
-          unless ws1.text_value.empty?
-            tokens.concat(ws1.tokens)
-          end
-
-          tokens.push({
-            type: 'T_COLON',
-            value: ':'
-          })
-
-          unless ws2.text_value.empty?
-            tokens.concat(ws2.tokens)
-          end
-
+          tokens.concat(ws1.tokens) unless ws1.text_value.empty?
+          tokens.push(T_COLON)
+          tokens.concat(ws2.tokens) unless ws2.text_value.empty?
           tokens.concat(value.tokens)
 
           tokens
@@ -111,21 +83,10 @@ module Kauri
 
           unless head.text_value.empty?
             head.elements.each { |e|
-
               tokens.concat(e.item.tokens)
-
-              unless e.ws1.text_value.empty?
-                tokens.concat(e.ws1.tokens)
-              end
-
-              tokens.push({
-                type: 'T_COMMA',
-                value: ','
-              })
-
-              unless e.ws2.text_value.empty?
-                tokens.concat(e.ws2.tokens)
-              end
+              tokens.concat(e.ws1.tokens) unless e.ws1.text_value.empty?
+              tokens.push(T_COMMA)
+              tokens.concat(e.ws2.tokens) unless e.ws2.text_value.empty?
             }
           end