objc-dependency-tree-generator 0.0.8 → 0.1.0

data/lib/objc_dependency_tree_generator.rb

@@ -1,13 +1,16 @@
 # encoding: UTF-8
+
 require 'optparse'
 require 'yaml'
 require 'json'
-require 'objc_dependency_tree_generator_helper'
-require 'swift_dependencies_generator'
-require 'objc_dependencies_generator'
-
-class ObjCDependencyTreeGenerator
-
+require 'helpers/objc_dependency_tree_generator_helper'
+require 'swift/swift_dependencies_generator'
+require 'objc/objc_dependencies_generator'
+require 'sourcekitten/sourcekitten_dependencies_generator'
+require 'dependency_tree'
+require 'tree_serializer'
+
+class DependencyTreeGenerator
   def initialize(options)
     @options = options
     @options[:derived_data_project_pattern] = '*-*' unless @options[:derived_data_project_pattern]
@@ -19,125 +22,139 @@ class ObjCDependencyTreeGenerator
   def self.parse_command_line_options
     options = {}
 
-#Defaults
+    # Defaults
     options[:derived_data_paths] = ['~/Library/Developer/Xcode/DerivedData', '~/Library/Caches/appCode*/DerivedData']
     options[:project_name] = ''
     options[:output_format] = 'json'
+    options[:verbose] = true
+    options[:swift_ast_show_parsed_tree] = false
+    options[:ignore_primitive_types] = true
+    options[:show_inheritance_only] = false
 
-
-    parser = OptionParser.new do |o|
+    OptionParser.new do |o|
       o.separator 'General options:'
-      o.on('-p PATH', '--path' ,'Path to directory where are your .o files were placed by the compiler', Array) { |directory|
+      o.on('-p PATH', '--path', 'Path to directory where are your .o files were placed by the compiler', Array) do |directory|
         options[:search_directories] = Array(options[:search_directories]) | Array(directory)
-      }
-      o.on('-D DERIVED_DATA', 'Path to directory where DerivedData is') { |derived_data|
+      end
+      o.on('-D DERIVED_DATA', 'Path to directory where DerivedData is') do |derived_data|
         options[:derived_data_paths] = [derived_data]
         options[:derived_data_project_pattern] = '*'
-      }
-      o.on('-s PROJECT_NAME', 'Search project .o files by specified project name') { |project_name|
+      end
+      o.on('-output PROJECT_NAME', 'Search project .o files by specified project name') do |project_name|
         options[:project_name] = project_name
-      }
-      o.on('-t TARGET_NAME', '--target' 'Target of project', Array) { |target_name|
+      end
+      o.on('-t TARGET_NAME', '--target', 'Target of project', Array) do |target_name|
         options[:target_names] = Array(options[:target_names]) | Array(target_name)
-      }
-      o.on('-e PREFIXES', "Prefixes of classes those will be exсluded from visualization. \n\t\t\t\t\tNS|UI\n\t\t\t\t\tUI|CA|MF") { |exclusion_prefixes|
+      end
+      o.on('-e PREFIXES', "Prefixes of classes those will be exсluded from visualization. \n\t\t\t\t\tNS|UI\n\t\t\t\t\tUI|CA|MF") do |exclusion_prefixes|
         options[:exclusion_prefixes] = exclusion_prefixes
-      }
+      end
 
-      o.on('-d', '--use-dwarf-info', 'Use DWARF Information also') { |v|
+      o.on('-d', '--use-dwarf-info', 'Use DWARF Information also') do |v|
         options[:use_dwarf] = v
-      }
-      o.on('-w', '--swift-dependencies', 'Generate swift project dependencies') { |v|
+      end
+
+      o.on('-w', '--swift-dependencies', 'Generate swift project dependencies') do |v|
         options[:swift_dependencies] = v
-      }
-      o.on('-f FORMAT', 'Output format. json by default. Possible values are [dot|json-pretty|json|json-var|yaml]') { |f|
+      end
+      o.on('-k FILENAME', 'Generate dependencies from source kitten output (json)') do |v|
+        options[:sourcekitten_dependencies_file] = v
+      end
+
+      o.on('--ast-file FILENAME', 'Generate dependencies from the swift ast dump output (ast)') do |v|
+        options[:swift_ast_dump_file] = v
+      end
+
+      o.on('--ast-show-parsed-tree', 'Show ast parsing info (for swift ast parser only)') do |_v|
+        options[:swift_ast_show_parsed_tree] = true
+      end
+
+      o.on('--inheritance-only', 'Show only inheritance dependencies') do
+        options[:show_inheritance_only] = true
+      end  
+
+      o.on('-f FORMAT', 'Output format. json by default. Possible values are [dot|json-pretty|json|json-var|yaml]') do |f|
         options[:output_format] = f
-      }
+      end
+      o.on('-o OUTPUT_FILE', '--output', 'target of output') do |f|
+        options[:target_file_name] = f
+      end
 
       o.separator 'Common options:'
-      o.on_tail('-h', 'Prints this help') { puts o; exit }
+      o.on_tail('-h', 'Prints this help') do
+        puts o
+        exit
+      end
       o.parse!
-
     end
 
     options
+  end
 
+  def find_objecte_files_directories
+    find_project_output_directory(
+      @options[:derived_data_paths],
+      @options[:project_name],
+      @options[:derived_data_project_pattern],
+      @options[:target_names],
+      @options[:verbose]
+      )
   end
 
-  def find_dependencies
-    if !@options or @options.empty?
-      return {}
-    end
+  def build_dependency_tree
+    tree = generate_depdendency_tree
+    tree.filter { |item, _| is_valid_dest?(item, @exclusion_prefixes) } if @options[:ignore_primitive_types]
+    tree.filter_links { |_ , _ , type | type == DependencyLinkType::INHERITANCE } if @options[:show_inheritance_only]
+    tree
+  end
 
-    unless @object_files_directories
-      @object_files_directories =
-          find_project_output_directory(@options[:derived_data_paths],
-                                        @options[:project_name],
-                                        @options[:derived_data_project_pattern],
-                                        @options[:target_names])
-      return {} unless @object_files_directories
-    end
+  def generate_depdendency_tree
+    return build_sourcekitten_dependency_tree if @options[:sourcekitten_dependencies_file]
+    return build_ast_dependency_tree if @options[:swift_ast_dump_file]
+    return tree_from_object_files_directory
+  end
 
-    unless @object_files_directories
-      puts parser.help
-      exit 1
-    end
+  def tree_from_object_files_directory
+    tree = DependencyTree.new
 
+    return tree if !@options || @options.empty?
+    @object_files_directories ||= find_objecte_files_directories
+    return tree unless @object_files_directories
 
-    links = {}
-    links_block = lambda { |source, dest|
-      links[source] = {} unless links[source]
-      if source != dest and is_valid_dest?(dest, @exclusion_prefixes)
-        links[source][dest] = 'set up'
-      end
-    }
-
+    update_tree_block = lambda { |source, target| tree.add(source, target) } 
     if @options[:swift_dependencies]
-      SwiftDependenciesGenerator.new.generate_dependencies(@object_files_directories, &links_block)
+      SwiftDependenciesGenerator.new.generate_dependencies(@object_files_directories, &update_tree_block)
     else
-      ObjcDependenciesGenerator.new.generate_dependencies(@object_files_directories, @options[:use_dwarf], &links_block)
+      ObjcDependenciesGenerator.new.generate_dependencies(@object_files_directories, @options[:use_dwarf], &update_tree_block)
     end
+    tree
+  end  
+
+  def build_ast_dependency_tree
+    require_relative 'swift-ast-dump/swift_ast_dependencies_generator'
+    generator = SwiftAstDependenciesGenerator.new(
+      @options[:swift_ast_dump_file],
+      @options[:swift_ast_show_parsed_tree]
+    )
+    generator.generate_dependencies
+  end
 
-    links
+  def build_sourcekitten_dependency_tree
+    generator = SourcekittenDependenciesGenerator.new(
+      @options[:sourcekitten_dependencies_file]
+    )
+    generator.generate_dependencies
   end
 
   def dependencies_to_s
-    links = find_dependencies
-    s = ''
-    if @options[:output_format] == 'json-var'
-      s+= <<-THEEND
-   var dependencies =
-      THEEND
-    end
+    tree = build_dependency_tree
+    serializer = TreeSerializer.new(tree)
+    output = serializer.serialize(@options[:output_format])
 
-    json_result = {}
-    json_links = []
-
-    links_count = 0
-    links.each do |source, dest_hash|
-      links_count = links_count + dest_hash.length
-      dest_hash.each do |dest, _|
-        json_links += [{'source' => source, 'dest' => dest}]
-      end
-    end
-    json_result['links'] = json_links
-    json_result['source_files_count'] = links.length
-    json_result['links_count'] = links_count
-
-    if @options[:output_format] == 'dot'
-      indent = "\t"
-      s = "digraph dependencies {\n#{indent}node [fontname=monospace, fontsize=9, shape=box, style=rounded]\n"
-      json_links.each do |link|
-        s += "#{indent}\"#{link['source']}\" -> \"#{link['dest']}\"\n"
-      end
-      s += "}\n"
+    if @options[:target_file_name]
+      File.open(@options[:target_file_name], 'w').write(output.to_s)
     else
-      s = s + JSON.pretty_generate(json_result) if @options[:output_format] == 'json-pretty'
-      s = s + json_result.to_json if @options[:output_format] == 'json' || @options[:output_format] == 'json-var'
-      s = s + json_result.to_yaml if @options[:output_format] == 'yaml'
+      output
     end
-    s
   end
-
-
-end
+end

data/lib/sourcekitten/sourcekitten_dependencies_generator.rb

@@ -0,0 +1,229 @@
+require 'json'
+require 'helpers/objc_dependency_tree_generator_helper'
+require 'rexml/document'
+require 'helpers/swift_primitives'
+
+module SKDeclarationType
+  SWIFT_EXTENSION = 'source.lang.swift.decl.extension'.freeze
+  SWIFT_PROTOCOL = 'source.lang.swift.decl.protocol'.freeze
+  SWIFT_STRUCT = 'source.lang.swift.decl.struct'.freeze
+  SWIFT_CLASS = 'source.lang.swift.decl.class'.freeze
+  OBJC_PROTOCOL = 'sourcekitten.source.lang.objc.decl.protocol'.freeze
+  OBJC_STRUCT = 'sourcekitten.source.lang.objc.decl.struct'.freeze
+  OBJC_CLASS = 'sourcekitten.source.lang.objc.decl.class'.freeze
+
+
+  INSTANCE_VARIABLE = 'source.lang.swift.decl.var.instance'.freeze
+  STATIC_VARIABLE = 'source.lang.swift.decl.var.static'.freeze
+  INSTANCE_METHOD = 'source.lang.swift.decl.function.method.instance'.freeze
+  CLASS_METHOD = 'source.lang.swift.decl.function.method.class'.freeze
+  CALL = 'source.lang.swift.expr.call'.freeze
+  ARGUMENT = 'source.lang.swift.expr.argument'.freeze
+  DICTIONARY = 'source.lang.swift.expr.dictionary'.freeze
+  ARRAY = 'source.lang.swift.expr.array'.freeze
+end
+
+module SKKey
+  SUBSTRUCTURE = 'key.substructure'.freeze
+  KIND = 'key.kind'.freeze
+  INHERITED_TYPES = 'key.inheritedtypes'.freeze
+  NAME = 'key.name'.freeze
+  TYPE_NAME = 'key.typename'.freeze
+  ANNOTATED_DECLARATION = 'key.annotated_decl'.freeze
+  FULLY_ANNOTATED_DECLARATION = 'key.fully_annotated_decl'.freeze
+end
+
+
+class SourcekittenDependenciesGenerator
+
+  def initialize(source_kitten_json)
+    @source_kitten_json = source_kitten_json
+  end
+  # @return [DependencyTree]
+  def generate_dependencies
+
+    @tree = DependencyTree.new
+    @context = []
+
+    file = File.read(@source_kitten_json)
+    parsed_files = JSON.parse(file)
+
+    parsed_files.each do |parsed_file|
+      parsed_file.each do |_path, contents|
+        substructures = contents[SKKey::SUBSTRUCTURE] || next
+        substructures.each { |substructure| parse_structure(substructure) }
+      end
+    end
+
+    @tree
+  end
+
+  def in_context(name)
+    @context.push(name)
+    yield
+    @context.pop
+  end
+
+  # @param [Hash] item array of sourcekitten substructure of class, protocol, whatever
+  # @param [DependencyItemType] type type of items to register
+  def register_item(item, type)
+    item_name = item[SKKey::NAME]
+    @tree.register(item_name, type)
+
+    inherited_types = item[SKKey::INHERITED_TYPES] || return
+
+    inherited_types.each do |inherited_type|
+      inherited_type_name = inherited_type[SKKey::NAME]
+      @tree.add(item_name, inherited_type_name)
+    end
+
+  end
+
+  # @param [Hash] element SourceKitten source
+  def parse_structure(element)
+
+    kind = element[SKKey::KIND]
+    item_name = element[SKKey::NAME]
+
+    case kind
+    when SKDeclarationType::SWIFT_EXTENSION
+      process_element(element, DependencyItemType::UNKNOWN)
+
+    when SKDeclarationType::SWIFT_PROTOCOL, SKDeclarationType::OBJC_PROTOCOL
+      process_element(element, DependencyItemType::PROTOCOL)
+
+    when SKDeclarationType::SWIFT_STRUCT, SKDeclarationType::OBJC_STRUCT
+      process_element(element, DependencyItemType::STRUCTURE)
+
+    when SKDeclarationType::SWIFT_CLASS, SKDeclarationType::OBJC_CLASS
+      process_element(element, DependencyItemType::CLASS)
+      register_types_from_annotated_declaration(element)
+
+    when SKDeclarationType::INSTANCE_VARIABLE, SKDeclarationType::INSTANCE_METHOD, SKDeclarationType::STATIC_VARIABLE, SKDeclarationType::CLASS_METHOD
+      @context.each do |el_name|
+        register_types_from_annotated_declaration(element, el_name)
+      end
+      parse_substructures(element)
+
+    when SKDeclarationType::CALL
+      if item_name
+        object_names = potential_object_names(item_name)
+        object_names.each { |on| @context.each { |el_name| @tree.add(el_name, on, DependencyLinkType::CALL)} }
+      end
+      parse_substructures(element)
+
+    when SKDeclarationType::ARGUMENT, SKDeclarationType::DICTIONARY, SKDeclarationType::ARRAY
+      parse_substructures(element)
+
+    else
+      # do nothing
+    end
+  end
+
+  # @param [Hash] item array of sourcekitten substructure of class, protocol, whatever
+  # @param [DependencyItemType] type type of items to register
+  def process_element(element, type)
+    register_item(element, type)
+    item_name = element[SKKey::NAME] || return
+    link_items_from_context(item_name)
+    in_context(item_name) do
+      parse_substructures(element)
+    end
+  end
+
+  def parse_substructures(element)
+    sub_structures = element[SKKey::SUBSTRUCTURE] || return
+    sub_structures.each { |it| parse_structure(it) }
+  end
+
+  def link_items_from_context(item_name)
+    @context.each { |el_name| @tree.add(el_name, item_name) }
+  end
+
+  def register_types_from_annotated_declaration(element, name = nil)
+    item_name = name || element[SKKey::NAME] || return
+    annotated_decl = element[SKKey::ANNOTATED_DECLARATION] || return
+
+    doc = REXML::Document.new(annotated_decl)
+
+    has_typealiases = false
+    doc.each_element('//Declaration/Type') do |el|
+      dependency_type = el.text.to_s
+
+      # get el type
+      attribute_el = el.attribute('usr') || next
+
+      if is_typealias(element, dependency_type)
+        has_typealiases = true
+        next
+      end
+
+      attribute = attribute_el.to_s
+      if attribute.start_with? 's:P'
+        @tree.add(item_name, dependency_type)
+        @tree.register(dependency_type, DependencyItemType::PROTOCOL)
+      elsif attribute.start_with? 'c:objc(pl)'
+        @tree.add(item_name, dependency_type)
+        @tree.register(dependency_type, DependencyItemType::PROTOCOL)
+      elsif attribute.start_with? 'c:objc(cs)'
+        @tree.add(item_name, dependency_type)
+        @tree.register(dependency_type, DependencyItemType::CLASS)
+      elsif attribute.start_with? 's:C'
+        @tree.add(item_name, dependency_type)
+        @tree.register(dependency_type, DependencyItemType::CLASS)
+      end
+    end
+
+    register_types_from_type_name(element, item_name) if has_typealiases
+  end
+
+  def register_types_from_type_name(element, item_name)
+    type_name_string = element[SKKey::TYPE_NAME] || return
+
+    generics = generic_parameters(element)
+    type_names(type_name_string)
+      .select { |type_name| !generics.include?(type_name) }
+      .each { |type_name| @tree.add(item_name, type_name) }
+
+  end
+
+  # @return [Array<String>] array of generic names for element
+  def generic_parameters(element)
+    fully_annotated_decl = element[SKKey::FULLY_ANNOTATED_DECLARATION]
+    return [] if fully_annotated_decl.nil?
+    generics = []
+    doc = REXML::Document.new(fully_annotated_decl)
+    doc.each_element('//decl.generic_type_param.name') do |el|
+      generics.push(el.text.to_s)
+    end
+    generics
+  end
+
+  def is_typealias(element, name)
+    fully_annotated_decl = element[SKKey::FULLY_ANNOTATED_DECLARATION]
+    return false if fully_annotated_decl.nil?
+    doc = REXML::Document.new(fully_annotated_decl)
+    doc.each_element('//ref.typealias') do |el|
+      return true if el.text.to_s == name
+    end
+
+    false
+  end
+
+  # Returns an array of strings, which represents type names
+  # @param [String] type_name_string sourcekitten type name
+  # @return [Array<String>] array of types, found in this type
+  def type_names(type_name_string)
+    type_name_string
+      .split(/\W+/)
+      .select { |t| !t.empty? }
+      .select { |t| !is_primitive_swift_type?(t) }
+  end
+
+  def potential_object_names(call_string)
+    (call_string.scan(/^[A-Z_][A-Za-z0-9_]+/) + call_string.scan(/\s[A-Z_][A-Za-z0-9_]+/))
+      .select { |t| !t.empty? }
+      .select { |t| !is_primitive_swift_type?(t) }
+  end
+
+end