cpp_dependency_graph 0.1.1 → 0.1.2

data/lib/cpp_dependency_graph/component_dependency_graph.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require_relative 'project'
+require_relative 'link'
+require_relative 'cycle_detector'
+
+# Dependency tree/graph of entire project
+class ComponentDependencyGraph
+  def initialize(project)
+    @project = project
+  end
+
+  def all_links
+    @all_links ||= build_hash_links
+  end
+
+  def all_cyclic_links
+    @all_cyclic_links ||= build_cyclic_links
+  end
+
+  def links(name)
+    return {} unless all_links.key?(name)
+    links = incoming_links(name)
+    links.merge!(outgoing_links(name))
+    links
+  end
+
+  private
+
+  def build_hash_links
+    raw_links = @project.source_components.values.map { |c| [c.name, @project.dependencies(c)] }.to_h
+    @cycle_detector ||= CycleDetector.new(raw_links)
+    links = raw_links.map do |source, source_links|
+      c_links = source_links.map { |target| Link.new(source, target, @cycle_detector.cyclic?(source, target)) }
+      [source, c_links]
+    end.to_h
+    links
+  end
+
+  def build_cyclic_links
+    cyclic_links = all_links.select { |_, links| links.any?(&:cyclic?) }
+    cyclic_links.each_value { |links| links.select!(&:cyclic?) }
+  end
+
+  def outgoing_links(name)
+    all_links.slice(name)
+  end
+
+  def incoming_links(target)
+    incoming_c_links = all_links.select { |_, c_links| c_links.any? { |link| link.target == target } }
+    incoming_c_links.map do |source, _|
+      link = Link.new(source, target, @cycle_detector.cyclic?(source, target))
+      [source, [link]]
+    end.to_h
+  end
+end

data/lib/cpp_dependency_graph/config.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+# Configuration data for project
+module Config
+  def source_file_extensions
+    '.{h,hpp,hxx,c,cpp,cxx,cc}'
+  end
+end

data/lib/cpp_dependency_graph/cycle_detector.rb

@@ -2,16 +2,14 @@
 
 require_relative 'cyclic_link'
 
-# Detects cycles between components
+# Detects cycles between nodes
 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
+  def initialize(links)
+    @cyclic_links = links.flat_map do |source, source_links|
+      source_links.select { |target| links[target].include?(source) }.map do |target|
+        [CyclicLink.new(source, target), true]
+      end
+    end.to_h
   end
 
   def cyclic?(source, target)
@@ -20,6 +18,6 @@ class CycleDetector
   end
 
   def to_s
-    @cyclic_links.each { |k, _| puts k }
+    @cyclic_links.keys
   end
 end

data/lib/cpp_dependency_graph/cyclic_link.rb

@@ -1,30 +1,27 @@
 # 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
+require 'set'
 
-  def nodeA
-    @nodeA
-  end
+# Represents a cyclic link betwee two nodes, it is special in the sense it is designed to be used as a key in a hash
+class CyclicLink
+  attr_reader :node_a
+  attr_reader :node_b
 
-  def nodeB
-    @nodeB
+  def initialize(node_a, node_b)
+    @node_a = node_a
+    @node_b = node_b
   end
 
   def eql?(other)
-    (@nodeA == other.nodeA && @nodeB == other.nodeB) ||
-    (@nodeA == other.nodeB && @nodeB == other.nodeA)
+    (@node_a == other.node_a && @node_b == other.node_b) ||
+      (@node_a == other.node_b && @node_b == other.node_a)
   end
 
   def hash
-    [@nodeA, @nodeB].to_set.hash
+    [@node_a, @node_b].to_set.hash
   end
 
   def to_s
-    "#{nodeA} <-> #{nodeB}"
+    "#{node_a} <-> #{node_b}"
   end
 end

data/lib/cpp_dependency_graph/dir_tree.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require 'json'
+
+require_relative 'config'
+
+# Returns a root directory as a tree of directories
+class DirTree
+  include Config
+
+  attr_reader :tree
+
+  def initialize(path)
+    @tree ||= File.directory?(path) ? parse_dirs(path) : {}
+  end
+
+  private
+
+  def parse_dirs(path, name = nil)
+    data = Hash.new{|h, k| h[k] = []}
+    data[:name] = (name || path)
+    # TODO: Use Dir.map.compact|filter instead here
+    Dir.foreach(path) do |entry|
+      next if ['..', '.'].include?(entry)
+      full_path = File.join(path, entry)
+      next unless File.directory?(full_path)
+      next unless source_files_present?(full_path)
+      data[:children] << parse_dirs(full_path, entry)
+    end
+    data
+  end
+
+  def source_files_present?(full_path)
+    files = Dir.glob(File.join(full_path, File.join('**', '*' + source_file_extensions)))
+    files.size.positive?
+  end
+
+  def to_s
+    @tree.to_json
+  end
+end

data/lib/cpp_dependency_graph/file_dependency_graph.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require_relative 'project'
+require_relative 'link'
+require_relative 'cycle_detector'
+
+# Dependency tree/graph of entire project
+class FileDependencyGraph
+  def initialize(project)
+    @project = project
+  end
+
+  def all_links
+    @all_links ||= build_hash_links
+  end
+
+  def all_cyclic_links
+    @all_cyclic_links ||= build_cyclic_links
+  end
+
+  def links(name)
+    return {} unless all_links.key?(name)
+    links = incoming_links(name)
+    links.merge!(outgoing_links(name))
+    links
+  end
+
+  private
+
+  def build_hash_links
+    raw_links = @project.source_components.values.map { |c| [c.name, @project.dependencies(c)] }.to_h
+    @cycle_detector ||= CycleDetector.new(raw_links)
+    links = raw_links.map do |source, source_links|
+      c_links = source_links.map { |target| Link.new(source, target, @cycle_detector.cyclic?(source, target)) }
+      [source, c_links]
+    end.to_h
+    links
+  end
+
+  def build_cyclic_links
+    cyclic_links = all_links.select { |_, links| links.any?(&:cyclic?) }
+    cyclic_links.each_value { |links| links.select!(&:cyclic?) }
+  end
+
+  def outgoing_links(name)
+    all_links.slice(name)
+  end
+
+  def incoming_links(target)
+    incoming_c_links = all_links.select { |_, c_links| c_links.any? { |link| link.target == target } }
+    incoming_c_links.map do |source, _|
+      link = Link.new(source, target, @cycle_detector.cyclic?(source, target))
+      [source, [link]]
+    end.to_h
+  end
+end

data/lib/cpp_dependency_graph/graph_to_dot_visualiser.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require 'graphviz'
+
+# Outputs a `dot` langugage representation of a dependency graph
+class GraphToDotVisualiser
+  def generate(deps, file)
+    @g = Graphviz::Graph.new('dependency_graph')
+    nodes = create_nodes(deps)
+    connect_nodes(deps, nodes)
+    File.write(file, @g.to_dot)
+  end
+
+  private
+
+  def create_nodes(deps)
+    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
+    nodes
+  end
+
+  def create_node(name)
+    node = @g.add_node(name)
+    node.attributes[:shape] = 'box3d'
+    node
+  end
+
+  def connect_nodes(deps, nodes)
+    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
+  end
+end

data/lib/cpp_dependency_graph/graph_to_graphml_visualiser.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+# Outputs a `graphml` langugage representation of a dependency graph
+class GraphToGraphmlVisualiser
+  def generate(deps, file)
+    # TODO: Implement
+  end
+end

data/lib/cpp_dependency_graph/graph_to_html_visualiser.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require 'json'
+
+# Outputs a `d3 force graph layout` equipped HTML representation of a dependency graph
+class GraphToHtmlVisualiser
+  def generate(deps, file)
+    connections = deps.flat_map do |_, links|
+      links.map do |link|
+        { source: link.source, dest: link.target }
+      end
+    end
+    json_connections = JSON.pretty_generate(connections)
+    template_file = resolve_file_path('views/index.html.template')
+    template = File.read(template_file)
+    contents = format(template, dependency_links: json_connections)
+    File.write(file, contents)
+  end
+
+  private
+
+  def resolve_file_path(path)
+    File.expand_path("../../../#{path}", __FILE__)
+  end
+end

data/lib/cpp_dependency_graph/include_dependency_graph.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 require_relative 'project'
-require_relative 'component_link'
+require_relative 'link'
 require_relative 'cycle_detector'
 
 # Returns a hash of intra-component include links
@@ -10,15 +10,30 @@ class IncludeDependencyGraph
     @project = project
   end
 
-  def include_links(component_name)
+  def all_links
+    components = @project.source_components
+    all_source_files = components.values.flat_map(&:source_files)
+    all_source_files.map do |file|
+      source = file.basename
+      links = file.includes.map { |inc| Link.new(source, inc, false) }
+      [source, links]
+    end.to_h
+  end
+
+  def all_cyclic_links
+    # TODO: Implement
+  end
+
+  def links(component_name)
     component = @project.source_component(component_name)
     source_files = component.source_files
+    external_includes = @project.external_includes(component)
     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]
+      source = file.basename
+      internal_includes = file.includes.reject { |inc| external_includes.any?(inc) }
+      links = internal_includes.map { |inc| Link.new(source, inc, false) }
+      [source, links]
     end.to_h
   end
 end

data/lib/cpp_dependency_graph/include_to_component_resolver.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require_relative 'source_component'
+
+# Resolves a given include to a source component
+class IncludeToComponentResolver
+  def initialize(components)
+    @components = components
+    @component_external_include_cache = {}
+    @component_include_map_cache = {}
+  end
+
+  def external_includes(component)
+    unless @component_external_include_cache.key?(component)
+      @component_external_include_cache[component] = external_includes_private(component)
+    end
+    @component_external_include_cache[component]
+  end
+
+  def component_for_include(include)
+    return '' unless source_files.key?(include)
+    @component_include_map_cache[include] = component_for_include_private(include) unless @component_include_map_cache.key?(include)
+    @component_include_map_cache[include]
+  end
+
+  private
+
+  def external_includes_private(component)
+    include_components = component.includes.map { |inc| [inc, component_for_include(inc)] }.to_h
+    external_include_components = include_components.delete_if { |_, c| c == component.name }
+    external_include_components.keys
+  end
+
+  def component_for_include_private(include)
+    header_file = source_files[include]
+    implementation_files = implementation_files(header_file)
+    return header_file.parent_component if implementation_files.empty?
+    implementation_files[0].parent_component
+  end
+
+  def implementation_files(header_file)
+    implementation_files = []
+    source_files.each_value do |file|
+      implementation_files.push(file) if file.basename_no_extension == header_file.basename_no_extension
+    end
+    implementation_files.reject! { |file| file.basename == header_file.basename }
+  end
+
+  def source_files
+    @source_files ||= build_source_file_map
+  end
+
+  def build_source_file_map
+    # TODO: SourceComponent should return a hash for source files which can be merged here
+    source_files = @components.values.flat_map(&:source_files)
+    source_files.map { |s| [s.basename, s] }.to_h
+  end
+end

data/lib/cpp_dependency_graph/link.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'set'
+
+# Represents a link between two entities, a source and a target
+class Link
+  attr_reader :source
+  attr_reader :target
+
+  def initialize(source, target, cyclic = false)
+    @source = source
+    @target = target
+    @cyclic = cyclic
+  end
+
+  def cyclic?
+    @cyclic
+  end
+
+  def ==(other)
+    (source == other.source && target == other.target && cyclic? == other.cyclic?) ||
+      (source == other.target && target == other.source && cyclic? == other.cyclic?)
+  end
+
+  def hash
+    [source, target, cyclic?].to_set.hash
+  end
+
+  def to_s
+    if cyclic?
+      "#{source} <-> #{target}"
+    else
+      "#{source} -> #{target}"
+    end
+  end
+
+  def to_json(*options)
+    { json_class: self.class.name,
+      source: source, target: target, cyclic: cyclic? }.to_json(*options)
+  end
+end