swift-ast-dump-parser 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: dc8754e58b54b5563e95e3f2abaa81782823aa1f
+  data.tar.gz: fb0ea24daf5b73f6b32be241bd33ea62e391d5be
+SHA512:
+  metadata.gz: 3def18d0b3d524c6879bf0d29c6d3e58ce4811b3069abe1c0054b0ac3b5691d951e0e314c6afe70106458c6ceb4f98b862f8dad863536d31ed4796737f722cd8
+  data.tar.gz: 91b56fbe416abaf10ad8029b57c45ed7530975766cb6bc96c7b1e662843019cea4ddb3faa144fa450d5d127ab4e5070e477982db5c632ec0eadc7b32172c96cf

data/bin/swift-ast-dump-parser

@@ -0,0 +1,8 @@
+#!/usr/bin/env ruby
+# encoding: UTF-8
+
+require 'swift_ast_dump_parser'
+
+ast_path = ARGV[0]
+@tree = SwiftAST::Parser.new().parse_build_log_output(File.read(ast_path))
+@tree.dump

data/lib/swift_ast_dump_parser.rb

@@ -0,0 +1,225 @@
+module SwiftAST
+  autoload :StringScanner, 'strscan'
+  class Parser 
+    def parse(string)
+      @scanner = StringScanner.new(string)
+      node = scan_children.first
+      node
+    end 
+
+    
+    def parse_build_log_output(string)
+      @scanner = StringScanner.new(string)
+      return unless @scanner.scan_until(/^\(source_file/)
+      unscan("(source_file")
+      children = scan_children
+
+      return if children.empty?
+      Node.new("ast", [], children)
+    end 
+
+
+    def scan_parameters
+      parameters = []
+
+      while true
+        @scanner.skip(/\s*/)
+        parameter = scan_parameter?
+        break unless parameter
+        parameters << parameter
+      end
+
+      parameters
+    end  
+
+    def scan_parameters_from_types
+      first_param = @scanner.scan(/\d+:/)
+      return [] unless first_param
+      return [first_param] + scan_parameters
+    end  
+
+    def scan_children(level = 0)
+      children = []
+      while true
+        return children unless whitespaces = whitespaces_at(level)
+        node_name = scan_name?
+        return children if node_name == "source_file" && level != 0 && unscan(node_name + whitespaces)
+        node_parameters = scan_parameters
+
+        node_children = scan_children(level + 1)
+
+        while next_params = scan_parameters_from_types  # these are stupid params alike
+          break if next_params.empty?
+          node_parameters += next_params
+          node_children += scan_children(level + 1)
+        end  
+        node = Node.new(node_name, node_parameters, node_children)
+
+        children << node
+        @scanner.scan(/(\s|\\|\n|\r|\t)*\)[\w\s]*/)
+      end  
+      children
+    end  
+
+    def whitespaces_at(level = 0)
+      whitespaces = @scanner.scan(/(\s|\\|\n|\r|\t)*\(/)
+      if level == 0 && whitespaces.nil?
+         whitespaces = @scanner.scan(/.*?\(source_file/m)
+         return nil unless whitespaces
+         unscan("source_file")
+      end
+      whitespaces 
+    end  
+
+    def unscan(string)
+      @scanner.pos = @scanner.pos - string.length
+    end  
+
+    def scan_name? 
+      el_name = @scanner.scan(/#?[\w:]+/)
+      el_name
+    end  
+
+    def scan_parameter?(is_parsing_rvalue = false)
+      #white spaces are skipped
+
+      # scan everything until space or opening sequence like ( < ' ". 
+      # Since we can end up with closing bracket - we alos check for )
+
+      prefix = @scanner.scan(/[^\s()'"\[\\]+/) if is_parsing_rvalue
+      prefix = @scanner.scan(/[^\s()<'"\[\\=]+/) unless is_parsing_rvalue
+
+      next_char = @scanner.peek(1)
+      return nil unless next_char
+      should_unwrap_strings = !is_parsing_rvalue && !prefix
+
+      case next_char
+      when " "   # next parameter
+        result = prefix
+      when "\\"   # next parameter
+        @scanner.scan(/./)
+        result = prefix
+
+      when "\n"   # next parameter
+        result = prefix
+      when ")"   # closing bracket == end of element
+        result = prefix
+      when "\""  # doube quoted string 
+        result = @scanner.scan(/./) + @scanner.scan_until(/"/)
+        result = result[1..-2] if should_unwrap_strings             
+        result = (prefix || "") + result
+      when "'"  # single quoted string 
+        result =  @scanner.scan(/./) + @scanner.scan_until(/'/)
+        result = result[1..-2] if should_unwrap_strings             
+        result = (prefix || "") + result + (scan_parameter?(is_parsing_rvalue) || "")
+      when "<"  # kinda generic
+        result = (prefix || "") + @scanner.scan(/./)
+        #in some cases this can be last char, just because we can end up with a=sdsd.function.< 
+        result += @scanner.scan_until(/>/) + (scan_parameter?(is_parsing_rvalue) || "") 
+      when "("
+        #rare case for enums in type (EnumType).enumValue
+        if !prefix && @scanner.check(/\([\w\s\(\)<>,:\]\[\.?]+\)\.\w+/)
+          return @scanner.scan(/\([\w\s\(\)<>,:\]\[\.?]+\)\.\w+/)
+        end  
+
+        return nil if !prefix && !is_parsing_rvalue
+        result = (prefix || "") + @scanner.scan_until(/\)/) + (scan_parameter?(is_parsing_rvalue) || "")
+       when "["
+        result = (prefix || "") + scan_range + (scan_parameter?(is_parsing_rvalue) || "")
+        #rare case for tuple_shuffle_expr [with ([ProductDict], UserDict)]0: ([ProductDict], UserDict)
+        if result.start_with?("[with") && result.end_with?("]0:")
+          result = result + @scanner.scan_until(/\n/).chomp("\n")
+
+        end  
+       when "=" 
+        result = prefix + @scanner.scan(/./) + (scan_parameter?(true) || "")
+
+      end  
+
+      result
+
+    end
+
+    def scan_range
+      return unless @scanner.peek(1) == "["
+      result = @scanner.scan(/./)
+
+      while true
+        inside = @scanner.scan(/[^\]\[]+/)  #everything but [ or ]
+        result += inside || ""
+        next_char = @scanner.peek(1)
+
+        return result + @scanner.scan(/./) if next_char == "]" # we found the end
+        result += scan_range if next_char == "["
+        raise "Unexpected character #{next_char} - [ or ] expected" if next_char != "[" && next_char != "]"
+      end
+
+    end  
+
+    def scan_line_and_column
+      @scanner.scan(/:\d+:\d+/)
+    end  
+
+    def isalpha(str)
+      !str.match(/[^A-Za-z@_]/)
+    end
+    def isAlphaDigit(str)
+      !str.match(/[^A-Za-z@_0-9]/)
+    end  
+    def isalphaOrDot(str)
+      !str.match(/[^A-Za-z@_.,]/)
+    end
+
+
+  end
+
+  class Node
+
+    def initialize(name, parameters = [], children = [])
+      @name = name
+      @parameters = parameters
+      @children = children
+    end    
+
+    def name
+      @name
+    end
+
+    def parameters
+      @parameters
+    end
+
+    def children
+      @children
+    end    
+
+    def dump(level = 0)
+      @@line = 0 if level == 0
+      puts "\n" if level == 0
+      puts " " * level + "[#{@@line}][#{@name} #{@parameters}"
+      @@line = @@line + 1
+      @children.each { |child| child.dump(level + 1) }
+    end  
+
+    def find_nodes(type)
+      found_nodes = []
+      @children.each { |child| 
+        if child.name == type
+           found_nodes << child
+        else
+           found_nodes += child.find_nodes(type)
+        end      
+      }
+      found_nodes
+    end  
+
+    def on_node(type, &block)
+      @children.each { |child|
+        yield child if child.name == type
+        child.on_node(type, &block)
+      }
+    end
+
+  end      
+
+end

metadata

@@ -0,0 +1,48 @@
+--- !ruby/object:Gem::Specification
+name: swift-ast-dump-parser
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Paul Taykalo
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2017-11-12 00:00:00.000000000 Z
+dependencies: []
+description: |2
+    Tool that allows to build AST tree representation from the swift's AST dump
+    swift-ast-dump-parser <ast-file>
+email: tt.kilew@gmail.com
+executables:
+- swift-ast-dump-parser
+extensions: []
+extra_rdoc_files: []
+files:
+- bin/swift-ast-dump-parser
+- lib/swift_ast_dump_parser.rb
+homepage: https://github.com/PaulTaykalo/swift-ast-dump-parser.git
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.6.10
+signing_key: 
+specification_version: 4
+summary: Swift AST dump parser
+test_files: []