objc-dependency-tree-generator 0.0.8 → 0.1.0

data/lib/swift-ast-dump/swift_ast_dependencies_generator.rb

@@ -0,0 +1,216 @@
+require 'helpers/objc_dependency_tree_generator_helper'
+require 'swift-ast-dump/swift_ast_parser'
+
+class SwiftAstDependenciesGenerator
+
+  def initialize(ast_file, dump_parsed_tree, verbose = false)
+    @ast_file = ast_file
+    @verbose = verbose
+    @dump_parsed_tree = dump_parsed_tree
+  end
+
+  # @return [DependencyTree]
+  def generate_dependencies
+
+    @tree = DependencyTree.new
+    @context = []
+    @generics_context = []
+
+    @ast_tree = SwiftAST::Parser.new().parse_build_log_output(File.read(@ast_file))
+    @ast_tree.dump if @dump_parsed_tree
+    scan_source_files
+
+    @tree
+  end
+
+  def scan_source_files
+    source_files = @ast_tree.find_nodes("source_file")
+    return scan_source_files_classes(@ast_tree) if source_files.empty?
+
+    source_files.each { |source_file|
+      scan_source_files_classes(source_file)       
+    }
+  end
+
+  def scan_source_files_classes(root)
+    classes = root.find_nodes("class_decl")
+    classes.each { |node| 
+      next unless classname = node.parameters.first
+      @tree.register(classname, DependencyItemType::CLASS) 
+    }
+
+    protocols = @ast_tree.find_nodes("protocol")
+    protocols.each { |node| 
+      next unless protoname = node.parameters.first
+      @tree.register(protoname, DependencyItemType::PROTOCOL) 
+    }
+
+    structs = @ast_tree.find_nodes("struct_decl")
+    structs.each { |node| 
+      next unless struct_name = node.parameters.first
+      @tree.register(struct_name, DependencyItemType::STRUCTURE) 
+    }
+
+    classes.each { |node| 
+      next unless classname = node.parameters.first
+      generic_names = register_generic_parameters(node, classname) 
+      @generics_context << generic_names
+      register_typealiases(node, classname)
+
+      register_inheritance(node, classname) 
+      register_variables(node, classname) 
+      register_calls(node, classname) 
+      register_function_parameters(node, classname) 
+
+      @generics_context.pop
+
+    }
+
+    protocols.each { |node|
+      return unless proto_name = node.parameters.first
+      generic_names = register_generic_parameters(node, proto_name) 
+      @generics_context << generic_names
+
+      register_inheritance(node, proto_name) 
+      register_function_parameters(node, proto_name) 
+      @generics_context.pop
+
+    }
+
+    structs.each { |node|
+      next unless classname = node.parameters.first
+      generic_names = register_generic_parameters(node, classname) 
+      @generics_context << generic_names
+      register_typealiases(node, classname)
+
+      register_inheritance(node, classname) 
+      register_variables(node, classname) 
+      register_calls(node, classname) 
+      register_function_parameters(node, classname) 
+
+      @generics_context.pop
+    }
+
+    extensions = @ast_tree.find_nodes("extension_decl")
+    extensions.each { |node|
+      return unless extension_name = node.parameters.first
+      register_inheritance(node, extension_name) 
+    }
+
+  end
+
+  def register_inheritance(node, name)
+    inheritance = node.parameters.drop_while { |el| el != "inherits:" }
+    inheritance = inheritance.drop(1)
+    inheritance.each { |inh| 
+      inh_name = inh.chomp(",")
+      add_tree_dependency(name, inh_name, DependencyLinkType::INHERITANCE)
+    }
+  end
+
+  def register_typealiases(node, name)
+    node.on_node("typealias") { |typealias|
+      typealias.parameters.select { |el| el.start_with?("type=") }.each { |type_decl|
+        type_name = type_decl.sub("type=", '')[1..-2].chomp("?")
+        add_tree_dependency(name, type_name, DependencyLinkType::PARAMETER)
+      }
+    }
+  end  
+
+  def register_generic_parameters(node, name)
+    return [] unless generic = node.parameters[1] # Second parameter
+    return [] unless generic[0] + generic[-1] == "<>" 
+
+    # REmove brackets
+    generic = generic[1..-2]
+
+    generic_decls = []
+    generic.split(",").each { |decl|
+      parts = decl.split(":")
+      leftPart = parts[0]
+      rightPart = parts[1]
+
+      next unless leftPart
+
+      generic_name = leftPart.strip || leftPart
+      generic_decls << generic_name
+
+      next unless rightPart
+
+
+      rightPart.split("&").each { |protocol_or_class|
+        proto_name = protocol_or_class.strip || protocol_or_class
+        add_tree_dependency(name, proto_name, DependencyLinkType::INHERITANCE)
+      }
+    }
+
+    generic_decls
+  end
+
+
+  def register_variables(node, name)  
+    node.on_node("var_decl") { |variable|
+      next unless type_decl = variable.parameters.find { |el| el.start_with?("type=") }
+      type_name = type_decl.sub("type=", '')[1..-2].chomp("?")
+      add_tree_dependency(name, type_name, DependencyLinkType::IVAR)
+    }
+  end  
+
+
+  def register_calls(node, name)
+    node.on_node("call_expr") { |variable|
+      next unless type_decl = variable.parameters.find { |el| el.start_with?("type=") }
+      type_name = type_decl.sub("type=", '')[1..-2].chomp("?")
+      add_tree_dependency(name, type_name, DependencyLinkType::CALL)
+    }
+  end
+
+  def register_function_parameters(node, name)  
+    node.on_node("func_decl") { |func_decl|
+
+      generic_names = register_generic_parameters(func_decl, name)
+      @generics_context << generic_names
+
+      func_decl.on_node("parameter_list") { |param_list|
+        param_list.on_node("parameter") { |parameter|
+          next unless type_decl = parameter.parameters.find { |el| el.start_with?("type=") }
+          type_name = type_decl.sub("type=", '')[1..-2].chomp("?")
+          add_tree_dependency(name, type_name, DependencyLinkType::PARAMETER)
+        }
+      }
+
+      func_decl.on_node("result") { |result_decl|
+        result_decl.on_node("type_ident") { |type_id|
+          type_id.on_node("component") { |comp|
+            next unless type_decl = comp.parameters.find { |el| el.start_with?("id=") }
+            type_name = type_decl.sub("id=", '')[1..-2].chomp("?")
+            add_tree_dependency(name, type_name, DependencyLinkType::PARAMETER)
+          }
+        }
+      }
+      @generics_context.pop
+    }
+  end 
+
+  def normalized_name(the_name)
+    the_name.sub("inout ", "")[/(\w|\d|\.)+/]
+  end
+
+  def add_tree_dependency(from_name, to_name, type) 
+    # skip names from generics
+    # we also will need to skip generics_from_functions
+    skip_names = (@generics_context || []).flatten
+
+    from = normalized_name(from_name)
+    return if skip_names.include? from
+
+    to = normalized_name(to_name)
+    return if skip_names.include? to
+
+    return unless to
+    return unless from
+    @tree.add(from, to, type)
+  end
+
+
+end

data/lib/swift-ast-dump/swift_ast_parser.rb

@@ -0,0 +1,217 @@
+module SwiftAST
+  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/)
+
+      @scanner.pos = @scanner.pos - 12
+      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)*\)/)
+      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 "("
+        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) || "")
+       when "=" 
+        result = prefix + @scanner.scan(/./) + (scan_parameter?(true) || "")
+
+      end  
+
+      # puts "prefix is '#{prefix}'  ||#{is_parsing_rvalue} result =#{result}"
+
+      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

data/lib/tree_serializer.rb

@@ -0,0 +1,64 @@
+class TreeSerializer
+  attr_reader :dependency_tree
+
+  # @param [DependencyTree] dependency_tree
+  def initialize(dependency_tree)
+    @dependency_tree = dependency_tree
+  end
+
+
+  # @return [String]
+  def serialize(output_format)
+    object_to_serialize = {}
+    object_to_serialize[:links] = @dependency_tree.links_with_types
+    object_to_serialize[:links_count] = @dependency_tree.links_count
+    object_to_serialize[:objects] = Hash[
+      @dependency_tree.objects.map do |o|
+        [o, { type: @dependency_tree.type(o) }]
+      end
+    ]
+
+    case output_format
+    when 'dot'
+      serialize_to_dot(object_to_serialize)
+    when 'json-pretty'
+      serialize_to_json_pretty(object_to_serialize)
+    when 'json'
+      serialize_to_json(object_to_serialize)
+    when 'json-var'
+      serialize_to_json_var(object_to_serialize)
+    when 'yaml'
+      serialize_to_yaml(object_to_serialize)
+    else
+      raise
+    end
+
+  end
+
+  def serialize_to_yaml(object_to_serialize)
+    object_to_serialize.to_yaml
+  end
+
+  def serialize_to_json_var(object_to_serialize)
+    'var dependencies = ' + object_to_serialize.to_json
+  end
+
+  def serialize_to_json(object_to_serialize)
+    object_to_serialize.to_json
+  end
+
+  def serialize_to_json_pretty(object_to_serialize)
+    JSON.pretty_generate(object_to_serialize)
+  end
+
+  def serialize_to_dot(object_to_serialize)
+    indent = "\t"
+    s = "digraph dependencies {\n#{indent}node [fontname=monospace, fontsize=9, shape=box, style=rounded]\n"
+    object_to_serialize[:links].each do |link|
+      s += "#{indent}\"#{link['source']}\" -> \"#{link['dest']}\"\n"
+    end
+    s += "}\n"
+    s
+  end
+
+end