cpp_dependency_graph 0.1.1

data/lib/cpp_dependency_graph/cycle_detector.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require_relative 'cyclic_link'
+
+# Detects cycles between components
+class CycleDetector
+  def initialize(component_links)
+    @cyclic_links = {}
+    component_links.each do |source, links|
+                      links.each do |target|
+                        links_of_target = component_links[target]
+                        @cyclic_links[CyclicLink.new(source, target)] = true if links_of_target.include?(source)
+                      end
+                    end
+  end
+
+  def cyclic?(source, target)
+    k = CyclicLink.new(source, target)
+    @cyclic_links.key?(k)
+  end
+
+  def to_s
+    @cyclic_links.each { |k, _| puts k }
+  end
+end

data/lib/cpp_dependency_graph/cyclic_link.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+# A special class designed to be used as a key in a hash
+class CyclicLink
+  def initialize(nodeA, nodeB)
+    @nodeA = nodeA
+    @nodeB = nodeB
+  end
+
+  def nodeA
+    @nodeA
+  end
+
+  def nodeB
+    @nodeB
+  end
+
+  def eql?(other)
+    (@nodeA == other.nodeA && @nodeB == other.nodeB) ||
+    (@nodeA == other.nodeB && @nodeB == other.nodeA)
+  end
+
+  def hash
+    [@nodeA, @nodeB].to_set.hash
+  end
+
+  def to_s
+    "#{nodeA} <-> #{nodeB}"
+  end
+end

data/lib/cpp_dependency_graph/dependency_graph.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require_relative 'project'
+require_relative 'component_link'
+require_relative 'cycle_detector'
+
+# Returns a hash of component links
+class DependencyGraph
+  def initialize(project)
+    @project = project
+  end
+
+  def components
+    @components ||= source_components
+  end
+
+  def all_component_links
+    @all_component_links ||= build_hash_component_links
+  end
+
+  def component_links(name)
+    return {} unless all_component_links.key?(name)
+    incoming_links(name).merge(outgoing_links(name))
+  end
+
+  private
+
+  def build_hash_component_links
+    raw_links = @project.source_components.map { |c| [c.name, @project.dependencies(c)] }.to_h
+    cycle_detector = CycleDetector.new(raw_links)
+    component_links = raw_links.map do |source, links|
+                        c_links = links.map { |target| ComponentLink.new(source, target, cycle_detector.cyclic?(source, target)) }
+                        [source, c_links]
+                      end.to_h
+    component_links
+  end
+
+  def outgoing_links(name)
+    all_component_links.slice(name)
+  end
+
+  def incoming_links(target)
+    incoming_c_links = all_component_links.select { |c, c_links| c_links.any? { |link| link.target == target } }
+    incoming_c_links.map do |c_name, _|
+      link = ComponentLink.new(c_name, target, false)
+      [c_name, [link]]
+    end.to_h
+  end
+end

data/lib/cpp_dependency_graph/graph_to_html_converter.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+# Generates an HTML file with a D3 force directed graph layout
+class GraphToHtmlConverter
+  def self.generate(graph, file)
+  end
+end

data/lib/cpp_dependency_graph/graph_visualiser.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require 'graphviz'
+require 'json'
+
+class GraphVisualiser
+  def generate_dot_file(deps, file)
+    @g = Graphviz::Graph.new(name = 'dependency_graph')
+
+    node_names = deps.flat_map do |_, links|
+                   links.map { |link| [link.source, link.target] }.flatten
+                 end.uniq
+    nodes = node_names.map { |name| [name, create_node(name)] }.to_h
+
+    deps.each do |source, links|
+      links.each do |link|
+        connection = nodes[source].connect(nodes[link.target])
+        connection.attributes[:color] = 'red' if link.cyclic?
+      end
+    end
+
+    File.write(file, @g.to_dot)
+    # Graphviz::output(g, path: 'file') # TODO: https://github.com/ioquatix/graphviz/issues/7
+  end
+
+  def generate_html_file(deps, file)
+    node_names = deps.flat_map do |_, links|
+                   links.map { |link| [link.source, link.target] }.flatten
+                 end.uniq
+    nodes = node_names.map { |name| { name: name } }
+
+    connections = deps.flat_map do |_, links|
+                    links.map do |link|
+                      { source: link.source, dest: link.target }
+                    end
+                  end
+
+    json_nodes = JSON.pretty_generate(nodes)
+    json_connections = JSON.pretty_generate(connections)
+    # File.write(file, json_nodes + json_connections)
+
+    template_file = resolve_file_path('views/index.html.template')
+    template = File.read(template_file)
+    contents = template % { dependency_links: json_connections }
+    File.write(file, contents)
+  end
+
+  private
+
+  def create_node(name)
+    node = @g.add_node(name)
+    node.attributes[:shape] = 'box3d'
+    node
+  end
+
+  def resolve_file_path(path)
+    File.expand_path("../../../#{path}", __FILE__)
+  end
+end

data/lib/cpp_dependency_graph/include_dependency_graph.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require_relative 'project'
+require_relative 'component_link'
+require_relative 'cycle_detector'
+
+# Returns a hash of intra-component include links
+class IncludeDependencyGraph
+  def initialize(project)
+    @project = project
+  end
+
+  def include_links(component_name)
+    component = @project.source_component(component_name)
+    source_files = component.source_files
+    source_files.map do |file|
+      class_name = file.basename
+      # TODO: Very inefficient
+      internal_includes = file.includes.reject { |inc| @project.external_includes(component).any?(inc) }
+      include_links = internal_includes.map { |inc| ComponentLink.new(class_name, inc, false) }
+      [class_name, include_links]
+    end.to_h
+  end
+end

data/lib/cpp_dependency_graph/project.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+require 'find'
+
+require_relative 'source_component'
+
+# Parses all components of a project
+class Project
+  def initialize(path)
+    @path = path
+  end
+
+  def source_components
+    @source_components ||= build_source_components
+  end
+
+  def source_component(name)
+    source_components.detect { |c| c.name == name }
+  end
+
+  def dependencies(component)
+    external_includes(component).map { |include| component_for_include(include) }.reject(&:empty?).uniq
+  end
+
+  def external_includes(component)
+    filter_internal_includes(component)
+  end
+
+  private
+
+  def build_source_components
+    # TODO: Dealing with source components with same dir name?
+    dirs = fetch_all_dirs(@path)
+    source_components = dirs.map { |dir| SourceComponent.new(dir) }
+    source_components.reject { |c| c.source_files.size.zero? }
+  end
+
+  def filter_internal_includes(component)
+    # TODO: This is super inefficient, refactor it
+    source_file_basenames = component.source_files.map(&:basename)
+    include_components = component.includes.map { |inc| [inc, component_for_include(inc)] }.to_h
+    filter = include_components.reject { |_, c| c == component.name }
+    filter.keys
+  end
+
+  def component_for_include(include)
+    header_file = source_files.find { |file| file.basename == include }
+    parent_component(header_file)
+  end
+
+  def source_files
+    @source_files ||= source_components.flat_map(&:source_files)
+  end
+
+  def parent_component(header_file)
+    return '' if header_file.nil?
+    files = source_files.select { |file| file.basename_no_extension == header_file.basename_no_extension }
+    corresponding_files = files.reject { |file| file.basename == header_file.basename }
+    return header_file.parent_component if corresponding_files.size == 0
+    corresponding_files[0].parent_component
+  end
+
+  def fetch_all_dirs(source_dir)
+    Find.find(source_dir).select { |e| File.directory?(e) }
+  end
+end

data/lib/cpp_dependency_graph/source_component.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require_relative 'source_file'
+
+class SourceComponent
+  def initialize(path)
+    @path = path
+  end
+
+  def path
+    @path
+  end
+
+  def name
+    @name ||= File.basename(@path)
+  end
+
+  def source_files
+    @source_files ||= parse_source_files('.{h,hpp,hxx,c,cpp,cxx,cc}')
+  end
+
+  def includes
+    @includes ||= source_files.flat_map(&:includes).uniq.map { |include| File.basename(include) }
+  end
+
+  def loc
+    @loc ||= source_files.inject(0) { |total_loc, file| total_loc + file.loc }
+  end
+
+  private
+
+  def parse_source_files(extensions)
+    path = File.join(@path, File::SEPARATOR) + '*' + extensions
+    files = Dir.glob(path).select { |e| File.file?(e) }
+    files.map { |file| SourceFile.new(file) }
+  end
+end

data/lib/cpp_dependency_graph/source_file.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+# Source file and metadata
+class SourceFile
+  def initialize(file)
+    @path = file
+  end
+
+  def basename
+    @basename ||= File.basename(@path)
+  end
+
+  def basename_no_extension
+    @basename_no_extension ||= File.basename(@path, File.extname(@path))
+  end
+
+  def path
+    @path ||= File.absolute_path(@path)
+  end
+
+  def header?
+    false     # TODO: Implement check extension
+  end
+
+  def parent_component
+    @parent_component ||= File.dirname(@path).split('/').last
+  end
+
+  def includes
+    @includes ||= all_includes
+  end
+
+  def loc
+    @loc ||= file_contents.lines.count
+  end
+
+  private
+
+  def all_includes
+    @all_includes ||= scan_includes
+  end
+
+  def scan_includes
+    # file_contents.scan(/#include "([^"]+)"/).uniq.flatten
+    file_contents.scan(/#include ["|<](.+)["|>]/).uniq.flatten   # TODO: use compiler lib to scan includes? llvm/clang?
+  end
+
+  def file_contents
+    @file_contents ||= File.read(@path)
+  end
+end

data/lib/cpp_dependency_graph/tsortable_hash.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require 'tsort'
+
+class TsortableHash < Hash
+  include TSort
+
+  alias tsort_each_node each_key
+  def tsort_each_child(node, &block)
+    fetch(node).each(&block)
+  end
+end

data/lib/cpp_dependency_graph/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module CppDependencyGraph
+  VERSION = '0.1.1'
+end

data/lib/cpp_dependency_graph.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require_relative 'cpp_dependency_graph/project'
+require_relative 'cpp_dependency_graph/dependency_graph'
+require_relative 'cpp_dependency_graph/include_dependency_graph'
+require_relative 'cpp_dependency_graph/graph_visualiser'
+require_relative 'cpp_dependency_graph/version'
+
+# Generates dependency graphs of a project in various output forms
+module CppDependencyGraph
+  def generate_project_graph(project_dir, format, output_file)
+    project = Project.new(project_dir)
+    graph = DependencyGraph.new(project)
+    deps = graph.all_component_links
+    generate_visualisation(deps, format, output_file)
+  end
+
+  def generate_component_graph(project_dir, component, format, output_file)
+    project = Project.new(project_dir)
+    graph = DependencyGraph.new(project)
+    deps = graph.component_links(component)
+    generate_visualisation(deps, format, output_file)
+  end
+
+  def generate_component_include_graph(project_dir, component_name, format, output_file)
+    project = Project.new(project_dir)
+    graph = IncludeDependencyGraph.new(project)
+    deps = graph.include_links(component_name)
+    generate_visualisation(deps, format, output_file)
+  end
+
+  def output_cyclic_dependencies(project_dir)
+    project = Project.new(project_dir)
+    graph = DependencyGraph.new(project)
+    deps = graph.all_component_links
+    cyclic_deps = deps.values.flatten.select { |dep| dep.cyclic? }
+    puts JSON.pretty_generate(cyclic_deps)
+  end
+
+  def generate_visualisation(deps, format, file)
+    case format
+    when 'dot'
+      GraphVisualiser.new.generate_dot_file(deps, file)
+    when 'html'
+      GraphVisualiser.new.generate_html_file(deps, file)
+    end
+  end
+end