visualize_packs 0.3.1 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 47c8efb8d5a5aa315cfea8c05a028fb0a042d55496f126a9f4b9bb031010deed
-  data.tar.gz: 7008a8249cad36c4d592513be2feac9ce77b316d30a3110dc4d83b366649721b
+  metadata.gz: 6f359f93291f20b1d7d77b62a32c52a7fa76baf86444201239f2b8e2bd629b83
+  data.tar.gz: e52a5b63f4ef80429727ed92d6e624329c6fe98904e0406b7b39b6f20a996121
 SHA512:
-  metadata.gz: 78c9e025d8d45167c33d803773d38865f99baf0fe5234c48c38962fb6af6e0cdb1c02961ded5a6c03e8fb9c64dc783ebc9789cd60c3199d32d1aca8fda79a395
-  data.tar.gz: 1e668887bae444783dd611d690923cfde71866620446b505e47b5765a19a2f787b73192ed41f1c38ed9faf24f0fabf82d42f9d836bc35a2a2ab0f0857d6e1756
+  metadata.gz: 2ec569b998d850151acf257f1cff5baf31a6fa7f3453dc1505776d33027b71f26fcb369c2d1b05cfef6d8d468b47a5b826e78859d485169b3bdcc163a634335c
+  data.tar.gz: 692b0eba45954340cbc043efd5b3937009ff402549ae3557e9d0013e827962c289ca1b9dc00eab399d9b0627099db42276912e566dfbd5e978960442f9bef649

data/README.md

@@ -1,35 +1,47 @@
 # visualize_packs
+Visualize_packs helps you visualize the structure, intended and actual, of your package-based Ruby application.
 
-This gem helps visualize relationships between packs.
+This gem takes a minimal approach in that it only outputs a graph in the format of [graphviz](https://graphviz.org/)' [dot language](https://graphviz.org/doc/info/lang.html). Install graphviz and use one of the chains of commands from below to generate full or partial images of the graphs of your application.
 
-![Example of visualization](docs/example.png)
+## Visualize your entire application
+```
+bundle exec visualize_packs > packs.dot && dot packs.dot -Tpng -o packs.png && open packs.png
+```
+
+## packs.png for every package in your app
+
+This will generate a local dependency diagram for every pack in your app
 
-# CLI Usage
-## bin/packs
-For simpler use, add `bin/packs` via `use_packs` (https://github.com/rubyatscale/use_packs)
 ```
-bin/packs visualize # all packs
-bin/packs visualize packs/a packs/b # subset of packs
-bin/packs # enter interactive mode to select what packs to visualize
+find . -iname 'package.yml' | sed 's/\/package.yml//g' | sed 's/\.\///' | xargs -I % sh -c "bundle exec visualize_packs --only=% > %/packs.dot && dot %/packs.dot -Tpng -o %/packs.png"
 ```
 
-# Ruby API Usage
-## Building a package graph for a selection of packages
-```ruby
-# Select the packs you want to include
-selected_packs = Packs.all
-selected_packs = Packs.all.select{ |p| ['packs/my_pack_1', 'packs/my_pack_2'].include?(p.name) }
-selected_packs = Packs.all.select{ |p| ['Team 1', 'Team 2'].include?(CodeOwnership.for_package(p)&.name) }
-VisualizePacks.package_graph!(selected_packs)
+If your app is large and has many packages and violations, the above graphs will likely be too big. Try this version to get only the edges to and from the focus package for each diagram:
+
 ```
+find . -iname 'package.yml' | sed 's/\/package.yml//g' | sed 's/\.\///' | xargs -I % sh -c "bundle exec visualize_packs --only=% --only-edges-to-focus > %/packs.dot && dot %/packs.dot -Tpng -o %/packs.png"
+```
+
 
-## Building a team graph for specific teams
-```ruby
-# Select the teams you want to include
-selected_teams = CodeTeams.all
-selected_teams = CodeTeams.all.select{ |t| ['Team 1', 'Team 2'].include?(t.name) }
-VisualizePacks.team_graph!(selected_teams)
+## Get help
+
+```
+bundle exec visualize_packs --help
 ```
 
-# Want to change something or add a feature?
-Submit a PR or post an issue!
+## What outputs look like
+
+![Sample diagrams produced](https://github.com/shageman/visualize_packs/blob/main/diagram_examples.png?raw=true)
+
+## Contributing
+
+To contribute, install graphviz (and the `dot` command). You must also have Ruby 3.2.2 and bundler installed. Then
+
+```
+cd spec
+./test.sh
+```
+
+Then, in `spec/sample_app` visually compare all `X.png` to `X_new.png` to make sure you are happy with the changes. If you, are, run `./update_cassettes.sh` in the same folder and commit the new test files with your changes.
+
+If you have imagemagick installed, you can then also run `./create_comparison.sh` to create one big image of all the before (left) and after (right) versions of the sample diagrams.

data/bin/visualize_packs

@@ -0,0 +1,39 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "pathname"
+require "optparse"
+require "ostruct"
+
+require_relative '../lib/visualize_packs'
+require_relative '../lib/options'
+
+options = Options.new
+
+OptionParser.new do |opt|
+  opt.on('--no-layers', "Don't show architectural layers") { |o| options.show_layers = false }
+  opt.on('--no-dependencies', "Don't show accepted dependencies") { |o| options.show_dependencies = false }
+  opt.on('--no-todos', "Don't show package todos") { |o| options.show_todos = false }
+  opt.on('--no-privacy', "Don't show privacy enforcement") { |o| options.show_privacy = false }
+  opt.on('--no-teams', "Don't show team colors") { |o| options.show_teams = false }
+
+  opt.on('--focus-on=PACKAGE', "Don't show privacy enforcement") { |o| options.focus_package = o }
+  opt.on('--only-edges-to-focus', "If focus is set, this shows only the edges to/from the focus node instead of all edges in the focussed graph. This only has effect when --focus-on is set.") { |o| options.show_only_edges_to_focus_package = true }
+
+  opt.on('--roll_nested_todos_into_top_level', "Don't show nested packages (not counting root). Connect edges to top-level package instead") { |o| options.roll_nested_todos_into_top_level = true }
+  opt.on('--focus_folder=FOLDER', "Draw package diagram only for packages in FOLDER") { |o| options.focus_folder = o }
+  opt.on('--no_nested_relationships', "Don't draw nested package relationships") { |o| options.show_nested_relationships = false }
+
+  opt.on('--remote-base-url=PACKAGE', "Link package nodes to an URL (affects graphviz SVG generation)") { |o| options.remote_base_url = o }
+
+  opt.on_tail("-h", "--help", "Show this message") do
+    puts opt
+    exit
+  end
+end.parse!
+
+puts VisualizePacks.package_graph!(
+  options, 
+  ParsePackwerk::Configuration.fetch.raw, 
+  Packs.all.map { |pack| ParsePackwerk.find(pack.name) }
+)

data/lib/graph.dot.erb

@@ -0,0 +1,162 @@
+digraph package_diagram {
+  rankdir=TD
+  graph [
+    labelloc="t"
+    fontname="Helvetica,Arial,sans-serif"
+    dpi=100
+    layout=dot
+    label=<%= title %>
+    fontsize=18
+  ]
+  node [
+    fontname="Helvetica,Arial,sans-serif"
+    fontsize=26.0
+    fontcolor=black
+    fillcolor=white
+    color=black
+    height=1.0
+    style=filled
+    shape=plain
+  ]
+  <%- architecture_layers.each_with_index do |layer_name, index| -%>
+    subgraph <%= layer_name -%> {
+      shape=box
+      color=darkgrey
+      fillcolor=lightblue
+      style=filled
+      <%- if layer_name != "NotInLayer" && options.show_layers -%>
+        label="<%= layer_name -%>"
+        cluster=true
+        rank = <%= index -%>
+      <%- else -%>
+        cluster=false
+      <%- end -%>
+      <%- grouped_packages[layer_name].each do |package| -%>
+        "<%= package.name -%>" [
+            fontsize=<%= options.focus_package && package.name == options.focus_package ? 18.0 : 12.0 -%>
+            <%- if options.remote_base_url %>
+              URL="<%= options.remote_base_url %>/<%= package.name == '.' ? '' : package.name -%>"
+            <%- end %>
+            <%- if options.show_teams && code_owner(package) -%>
+              style=filled
+              fillcolor="<%= node_color.call(code_owner(package)) %>"
+            <%- end -%>
+            label= <%- if package.enforce_privacy && options.show_privacy -%><
+                <table border='0' cellborder='1' cellspacing='0' cellpadding='16'><tr><td>
+                  <table border='0' cellborder='1' cellspacing='0' cellpadding='4'>
+                    <tr> <td port='private'> <%= package.name -%> </td> </tr>
+                  </table>
+                </td></tr></table>
+              >
+            <%- else -%><
+                <table border='0' cellborder='1' cellspacing='0' cellpadding='4'>
+                  <tr> <td align='left'> <%= package.name -%> </td> </tr>
+                </table>
+              >
+            <%- end -%>
+          ]
+        
+      <%- end -%>
+    }
+    <%- grouped_packages[layer_name].each do |package| -%>
+      <%- if options.show_layers -%>
+        <%- if index > 0 -%>
+          <%- grouped_packages[raw_config['architecture_layers'][index - 1]].each do |upper_layer_node| -%>
+            <%- if all_package_names.include?(upper_layer_node.name) && all_package_names.include?(package.name) -%>
+              "<%= upper_layer_node.name -%>" -> "<%= package.name -%>" [ style=invis ]
+            <%- end -%>
+          <%- end -%>
+        <%- end -%>
+      <%- end -%>
+    <%- end -%>
+  <%- end -%>
+  <%- if options.show_dependencies -%>
+    <%- all_packages.each do |package| -%>
+      <%- package.dependencies.each do |to_package| -%>
+        <%- if show_edge.call(package.name, to_package) -%>
+          "<%= package.name -%>" -> "<%= to_package -%>" [ color=darkgreen ]
+        <%- end -%>
+      <%- end -%>
+    <%- end -%>
+  <%- end -%>
+  <%- if options.show_todos -%>
+    <%- all_packages.each do |package| -%>
+      <%- violations_by_package = package.violations.group_by(&:to_package_name) -%>
+      <%- violations_by_package.keys.each do |violations_to_package| -%>
+        <%- violation_types = violations_by_package[violations_to_package].group_by(&:type) -%>
+        <%- violation_types.keys.each do |violation_type| -%>
+          <%- if show_edge.call(package.name, violations_to_package) -%>
+            "<%= package.name -%>" -> "<%= violations_to_package -%>"<%= violation_type == 'privacy' ? ':private' : '' -%> [ color=darkred style=dashed
+              constraint=false
+              # headlabel="<%= violation_type -%>"
+              <%- if violation_type == 'privacy' -%>
+                arrowhead=crow
+              <%- elsif violation_type == 'architecture' -%>
+                arrowhead=invodot
+              <%- elsif violation_type == 'visibility' -%>
+                arrowhead=obox
+              <%- elsif violation_type == 'dependency' -%>
+                arrowhead=odot
+              <%- end -%>
+              <%-
+                max_edge_width = 10
+                edge_width = (violation_types[violation_type].count / max_violation_count.to_f * max_edge_width).to_i
+              -%>
+              penwidth=<%= edge_width -%>
+            ]
+          <%- end -%>
+        <%- end -%>
+      <%- end -%>
+    <%- end -%>
+  <%- end -%>
+  <%- if options.show_nested_relationships -%>
+  <%- all_packages.each do |package| -%>
+    <%- all_packages.each do |nested_package| -%>
+      <%- if nested_package.name.include?(package.name) && !(nested_package.name == package.name) -%>
+        "<%= package.name -%>" -> "<%= nested_package.name -%>" [ color=purple penwidth=3 ]
+      <%- end -%>
+    <%- end -%>
+  <%- end -%>
+<%- end -%>
+  subgraph cluster_legend {
+    fontsize=16
+    label="Edges Styles and Arrow Heads"
+    A [ fontsize=12 shape=box label="package"]
+    B [ fontsize=12 shape=box label="package"]
+    C [ fontsize=12 shape=box label="package"]
+    D [ fontsize=12 shape=box label="package"]
+    E [ fontsize=12 shape=box label="package"]
+    F [ fontsize=12 shape=box label="package"]
+    G [ fontsize=12 shape=box label="package"]
+    H [ fontsize=12 shape=box label="package"]
+    I [ fontsize=12 shape=box label="package"]
+    J [ fontsize=12 shape=box label="package"]
+    K [ fontsize=12 shape=box label="package"]
+    L [ fontsize=12 shape=box label="package"]
+    A -> B [label="accepted dependency" color=darkgreen]
+    C -> D [label="privac todo" color=darkred style=dashed arrowhead=crow]
+    E -> F [label="architecture todo" color=darkred style=dashed arrowhead=invodot]
+    G -> H [label="visibility todo" color=darkred style=dashed arrowhead=obox]
+    I -> J [label="dependency todo" color=darkred style=dashed arrowhead=odot]
+    K -> L [label="nested package" color=purple penwidth=3]
+  }
+  <%- if options.show_teams && all_team_names != [] -%>
+  subgraph cluster_teams_legend {
+    fontsize=16
+    label="Team Colors"
+
+    <%- all_team_names.each do |team_name| -%>
+      <%- if team_name -%>
+      "<%= team_name %><%= team_name %>" [
+        label="<%= team_name %>"
+        style=filled
+        fillcolor="<%= node_color.call(team_name) %>"
+        fontsize=12
+        shape=box
+      ]
+      <%- end %>
+    <%- end -%>
+  }
+  J -> "<%= all_team_names.last %><%= all_team_names.last %>" [style=invis]
+  <%- end -%>
+}

data/lib/options.rb

@@ -0,0 +1,33 @@
+class Options
+  attr_accessor :show_layers
+  attr_accessor :show_dependencies
+  attr_accessor :show_todos
+  attr_accessor :show_privacy
+  attr_accessor :show_teams
+
+  attr_accessor :focus_package
+  attr_accessor :show_only_edges_to_focus_package
+
+  attr_accessor :roll_nested_todos_into_top_level
+  attr_accessor :focus_folder
+  attr_accessor :show_nested_relationships
+
+  attr_accessor :remote_base_url
+
+  def initialize
+    @show_layers = true
+    @show_dependencies = true
+    @show_todos = true
+    @show_privacy = true
+    @show_teams = true
+
+    @focus_package = nil
+    @show_only_edges_to_focus_package = false
+
+    @roll_nested_todos_into_top_level = false
+    @focus_folder = nil
+    @show_nested_relationships = true
+
+    @remote_base_url = nil
+  end
+end

data/lib/visualize_packs.rb

@@ -1,29 +1,213 @@
-# typed: strict
-
+require 'erb'
 require 'packs-specification'
 require 'parse_packwerk'
-require 'code_ownership'
-require 'graphviz'
-require 'sorbet-runtime'
-
-require 'visualize_packs/node_interface'
-require 'visualize_packs/graph_interface'
-require 'visualize_packs/team_node'
-require 'visualize_packs/package_node'
-require 'visualize_packs/team_graph'
-require 'visualize_packs/package_graph'
-require 'visualize_packs/package_relationships'
+require 'digest/md5'
 
 module VisualizePacks
-  extend T::Sig
 
-  sig { params(packages: T::Array[Packs::Pack]).void }
-  def self.package_graph!(packages)
-    PackageRelationships.new.create_package_graph!(packages)
+  def self.package_graph!(options, raw_config, packages)
+    raise ArgumentError, "Package #{options.focus_package} does not exist. Found packages #{packages.map(&:name).join(", ")}" if options.focus_package && !packages.map(&:name).include?(options.focus_package)
+
+    all_packages = filtered(packages, options.focus_package, options.focus_folder).sort_by {|x| x.name }
+    all_package_names = all_packages.map &:name
+
+    all_packages = remove_nested_packs(all_packages) if options.roll_nested_todos_into_top_level
+
+    show_edge = show_edge_builder(options, all_package_names)
+    node_color = node_color_builder()
+    max_violation_count = max_violation_count(all_packages, show_edge)
+
+    title = diagram_title(options, max_violation_count)
+
+    architecture_layers = (raw_config['architecture_layers'] || []) + ["NotInLayer"]
+    grouped_packages = architecture_layers.inject({}) do |result, key|
+      result[key] = []
+      result
+    end
+
+    all_packages.each do |package|
+      key = package.config['layer'] || "NotInLayer"
+      if architecture_layers.include?(key)
+        grouped_packages[key] << package
+      else
+        raise RuntimeError, "Package #{package.name} has architecture layer key #{key}. Known layers are only #{architecture_layers.join(", ")}"
+      end
+    end
+
+
+    all_team_names = all_packages.map { |p| code_owner(p) }.uniq
+
+    file = File.open(File.expand_path File.dirname(__FILE__) + "/graph.dot.erb")
+    templ = file.read.gsub(/^ *(<%.+%>) *$/, '\1')
+    template = ERB.new(templ, trim_mode: "<>-")
+    template.result(binding)
+  end
+
+  private 
+
+  def self.code_owner(package)
+    package.config.dig("metadata", "owner") || package.config["owner"]
+  end
+
+  def self.diagram_title(options, max_violation_count)
+    app_name = File.basename(Dir.pwd)
+    focus_edge_info = options.focus_package && options.show_only_edges_to_focus_package ? "showing only edges to/from focus pack" : "showing all edges between visible packs"
+    focus_info = options.focus_package || options.focus_folder ? "Focus on #{[options.focus_package, options.focus_folder].compact.join(' and ')} (#{focus_edge_info})" : "All packs"
+    skipped_info = 
+    [
+      options.show_layers ? nil : "hiding layers",
+      options.show_dependencies ? nil : "hiding dependencies",
+      options.show_todos ? nil : "hiding todos",
+      options.show_privacy ? nil : "hiding privacy",
+      options.show_teams ? nil : "hiding teams",
+      options.roll_nested_todos_into_top_level ? "hiding nested packs" : nil,
+      options.show_nested_relationships ? nil : "hiding nested relationships",
+    ].compact.join(', ').strip
+    main_title = "#{app_name}: #{focus_info}#{skipped_info != '' ? ' - ' + skipped_info : ''}"
+    sub_title = ""
+    if options.show_todos && max_violation_count
+      sub_title = "<br/><font point-size='12'>Widest todo edge is #{max_violation_count} violation#{max_violation_count > 1 ? 's' : ''}</font>"
+    end
+    "<<b>#{main_title}</b>#{sub_title}>"
+  end
+
+  def self.show_edge_builder(options, all_package_names)
+    return lambda do |start_node, end_node|
+      (
+        !options.show_only_edges_to_focus_package && 
+        all_package_names.include?(start_node) && 
+        all_package_names.include?(end_node)
+      ) ||
+      (
+        options.show_only_edges_to_focus_package && 
+        all_package_names.include?(start_node) && 
+        all_package_names.include?(end_node) && 
+        [start_node, end_node].include?(options.focus_package)
+      )
+    end
+  end
+
+  def self.node_color_builder
+    return lambda do |text|
+      return unless text
+      hash_value = Digest::SHA256.hexdigest(text.encode('utf-8'))
+      color_code = hash_value[0, 6]
+      r = color_code[0, 2].to_i(16) % 128 + 128
+      g = color_code[2, 2].to_i(16) % 128 + 128
+      b = color_code[4, 2].to_i(16) % 128 + 128
+      hex = "#%02X%02X%02X" % [r, g, b]
+    end
   end
 
-  sig { params(teams: T::Array[CodeTeams::Team]).void }
-  def self.team_graph!(teams)
-    PackageRelationships.new.create_team_graph!(teams)
+  def self.max_violation_count(all_packages, show_edge)
+    violation_counts = {}
+    all_packages.each do |package|
+      violations_by_package = package.violations.group_by(&:to_package_name)
+      violations_by_package.keys.each do |violations_to_package|
+        violation_types = violations_by_package[violations_to_package].group_by(&:type)
+        violation_types.keys.each do |violation_type|
+          if show_edge.call(package.name, violations_to_package)
+            key = "#{package.name}->#{violations_to_package}:#{violation_type}"
+            violation_counts[key] = violation_types[violation_type].count
+            # violation_counts[key] += 1
+          end
+        end
+      end
+    end
+    violation_counts.values.max
+  end
+
+  def self.filtered(packages, filter_package, filter_folder)
+    return packages unless filter_package || filter_folder
+
+    result = packages.map { |pack| pack.name }
+
+    if filter_package
+      result = [filter_package]
+      result += packages.select{ |p| p.dependencies.include? filter_package }.map { |pack| pack.name }
+      result += ParsePackwerk.find(filter_package).dependencies
+      result += packages.select{ |p| p.violations.map(&:to_package_name).include? filter_package }.map { |pack| pack.name }
+      result += ParsePackwerk.find(filter_package).violations.map(&:to_package_name)
+      result = result.uniq
+    end
+
+    if filter_folder
+      result = result.select { |p| p.include? filter_folder }
+    end
+
+    result.map { |pack_name| ParsePackwerk.find(pack_name) }
+  end
+
+  def self.all_nested_packages(all_package_names)
+    all_package_names.reject { |p| p == '.' }.inject({}) do |result, package|
+      package_map_tally = all_package_names.map { |other_package| Pathname.new(package).parent.to_s.include?(other_package) }
+      if package_map_tally.tally[true].nil?
+        #nothing to do
+      elsif package_map_tally.tally[true] > 1
+        raise "Can't handle multiple levels of nesting atm"
+      elsif package_map_tally.tally[true] == 1
+        result[package] = all_package_names[package_map_tally.find_index(true)]
+      end
+      result
+    end
+  end
+
+  def self.remove_nested_packs(packages)
+    nested_packages = all_nested_packages(packages.map { |p| p.name })
+
+    # top-level packages
+    morphed_packages = packages.map do |package|
+      if nested_packages.include?(package.name)
+        package
+      else
+        # nested packages
+        nested_packages.keys.each do |nested_package_name|
+          if nested_packages[nested_package_name] == package.name
+            nested_package = packages.find { |p| p.name == nested_package_name }
+
+            package = ParsePackwerk::Package.new(
+              name: package.name,
+              enforce_dependencies: package.enforce_dependencies,
+              enforce_privacy: package.enforce_privacy,
+              public_path: package.public_path,
+              metadata: package.metadata,
+              dependencies: package.dependencies + nested_package.dependencies,
+              config: package.config,
+              violations: package.violations + nested_package.violations
+            )
+          end
+        end
+
+
+        morphed_dependencies = package.dependencies.map do |d|
+          nested_packages[d] || d
+        end.uniq.reject { |p| p == package.name }
+
+        morphed_violations = package.violations.map do |v|
+          ParsePackwerk::Violation.new(
+            type: v.type, 
+            to_package_name: nested_packages[v.to_package_name] || v.to_package_name, 
+            class_name: v.class_name, 
+            files: v.files
+          )
+        end.reject { |v| v.to_package_name == package.name }
+
+
+        new_package = ParsePackwerk::Package.new(
+          name: package.name,
+          enforce_dependencies: package.enforce_dependencies,
+          enforce_privacy: package.enforce_privacy,
+          public_path: package.public_path,
+          metadata: package.metadata,
+          dependencies: morphed_dependencies,
+          config: package.config,
+          violations: morphed_violations
+        )
+        # add dependencies TO nested packages to top-level package
+        # add violations TO nested packages to top-level package
+      end
+    end
+
+    morphed_packages.reject { |p| nested_packages.keys.include?(p.name) }
   end
 end

metadata

@@ -1,79 +1,23 @@
 --- !ruby/object:Gem::Specification
 name: visualize_packs
 version: !ruby/object:Gem::Version
-  version: 0.3.1
+  version: 0.5.0
 platform: ruby
 authors:
 - Gusto Engineers
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2023-08-09 00:00:00.000000000 Z
+date: 2023-08-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: sorbet-runtime
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-- !ruby/object:Gem::Dependency
-  name: packs-specification
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-- !ruby/object:Gem::Dependency
-  name: parse_packwerk
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-- !ruby/object:Gem::Dependency
-  name: code_ownership
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-- !ruby/object:Gem::Dependency
-  name: rake
+  name: bundler
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-  type: :runtime
+  type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
@@ -81,55 +25,41 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: ruby-graphviz
+  name: sorbet-runtime
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-  type: :runtime
+  type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-- !ruby/object:Gem::Dependency
-  name: bundler
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 2.2.16
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 2.2.16
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.0'
+        version: '3.12'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.0'
+        version: '3.12'
 - !ruby/object:Gem::Dependency
-  name: sorbet
+  name: packs-specification
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-  type: :development
+  type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
@@ -137,36 +67,32 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: tapioca
+  name: parse_packwerk
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
+        version: 0.20.0
+  type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 0.20.0
 description: A gem to visualize connections in a Ruby app that uses packs
 email:
 - dev@gusto.com
-executables: []
+executables:
+- visualize_packs
 extensions: []
 extra_rdoc_files: []
 files:
 - README.md
+- bin/visualize_packs
+- lib/graph.dot.erb
+- lib/options.rb
 - lib/visualize_packs.rb
-- lib/visualize_packs/graph_interface.rb
-- lib/visualize_packs/legend.png
-- lib/visualize_packs/node_interface.rb
-- lib/visualize_packs/package_graph.rb
-- lib/visualize_packs/package_node.rb
-- lib/visualize_packs/package_relationships.rb
-- lib/visualize_packs/team_graph.rb
-- lib/visualize_packs/team_node.rb
 homepage: https://github.com/rubyatscale/visualize_packs
 licenses:
 - MIT

data/lib/visualize_packs/graph_interface.rb

@@ -1,17 +0,0 @@
-# typed: strict
-
-module VisualizePacks
-  # This stores graphviz-independent views of our package graph.
-  # It should be optimized for fast lookup (leveraging internal indexes, which are stable due to the immutability of the package nodes)
-  # A `TeamGraph` should be able to consume this and basically just create a reduced version
-  # Lastly, each one should implement a common interface, and graphviz should use that interface and take in either types of graph via the interface
-  module GraphInterface
-    extend T::Sig
-    extend T::Helpers
-    interface!
-
-    sig { abstract.returns(T::Set[NodeInterface]) }
-    def nodes
-    end
-  end
-end

data/lib/visualize_packs/node_interface.rb

@@ -1,29 +0,0 @@
-# typed: strict
-
-module VisualizePacks
-  module NodeInterface
-    extend T::Sig
-    extend T::Helpers
-    interface!
-
-    sig { abstract.returns(String) }
-    def name
-    end
-
-    sig { abstract.returns(String) }
-    def group_name
-    end
-
-    sig { abstract.returns(T::Hash[String, Integer]) }
-    def violations_by_node_name
-    end
-
-    sig { abstract.returns(T::Array[String]) }
-    def dependencies
-    end
-
-    sig { abstract.params(node_name: String).returns(T::Boolean) }
-    def depends_on?(node_name)
-    end
-  end
-end

data/lib/visualize_packs/package_graph.rb

@@ -1,54 +0,0 @@
-# typed: strict
-
-module VisualizePacks
-  class PackageGraph
-    extend T::Sig
-    include GraphInterface
-
-    sig { returns(T::Set[PackageNode]) }
-    attr_reader :package_nodes
-
-    sig { override.returns(T::Set[NodeInterface]) }
-    def nodes
-      package_nodes
-    end
-
-    sig { params(package_nodes: T::Set[PackageNode]).void }
-    def initialize(package_nodes:)
-      @package_nodes = package_nodes
-      @index_by_name = T.let({}, T::Hash[String, T.nilable(PackageNode)])
-    end
-
-    sig { returns(PackageGraph) }
-    def self.construct
-      package_nodes = Set.new
-      Packs.all.each do |p|
-        owner = CodeOwnership.for_package(p)
-
-        # Here we need to load the package violations and dependencies,
-        # so we need to use ParsePackwerk to parse that information.
-        package_info = ParsePackwerk.find(p.name)
-        next unless package_info # This should not happen unless packs/parse_packwerk change implementation
-
-        violations = package_info.violations
-        violations_by_package = violations.group_by(&:to_package_name).transform_values(&:count)
-
-        dependencies = package_info.dependencies
-
-        package_nodes << PackageNode.new(
-          name: p.name,
-          team_name: owner&.name || 'Unknown',
-          violations_by_package: violations_by_package,
-          dependencies: Set.new(dependencies)
-        )
-      end
-
-      PackageGraph.new(package_nodes: package_nodes)
-    end
-
-    sig { params(name: String).returns(T.nilable(PackageNode)) }
-    def package_by_name(name)
-      @index_by_name[name] ||= package_nodes.find { |node| node.name == name }
-    end
-  end
-end

data/lib/visualize_packs/package_node.rb

@@ -1,28 +0,0 @@
-# typed: strict
-
-module VisualizePacks
-  class PackageNode < T::Struct
-    extend T::Sig
-    include NodeInterface
-
-    const :name, String
-    const :team_name, String
-    const :violations_by_package, T::Hash[String, Integer]
-    const :dependencies, T::Set[String]
-
-    sig { override.returns(T::Hash[String, Integer]) }
-    def violations_by_node_name
-      violations_by_package
-    end
-
-    sig { override.returns(String) }
-    def group_name
-      team_name
-    end
-
-    sig { override.params(node_name: String).returns(T::Boolean) }
-    def depends_on?(node_name)
-      dependencies.include?(node_name) || (violations_by_package[node_name] || 0) > 0
-    end
-  end
-end

data/lib/visualize_packs/package_relationships.rb

@@ -1,170 +0,0 @@
-# typed: strict
-
-module VisualizePacks
-  class PackageRelationships
-    extend T::Sig
-
-    OUTPUT_FILENAME = T.let('packwerk.png'.freeze, String)
-
-    sig { params(teams: T::Array[CodeTeams::Team]).void }
-    def create_package_graph_for_teams!(teams)
-      packages = Packs.all.select do |package|
-        teams.map(&:name).include?(CodeOwnership.for_package(package)&.name)
-      end
-
-      create_package_graph!(packages)
-    end
-
-    sig { params(teams: T::Array[CodeTeams::Team], show_all_teams: T::Boolean).void }
-    def create_team_graph!(teams, show_all_teams: false)
-      package_graph = PackageGraph.construct
-      team_graph = TeamGraph.from_package_graph(package_graph)
-      node_names = teams.map(&:name)
-
-      draw_graph!(team_graph, node_names, show_all_nodes: show_all_teams)
-    end
-
-    sig { params(packages: T::Array[Packs::Pack]).void }
-    def create_package_graph!(packages)
-      graph = PackageGraph.construct
-      node_names = packages.map(&:name)
-      draw_graph!(graph, node_names)
-    end
-
-    sig { params(packages: T::Array[Packs::Pack], show_all_nodes: T::Boolean).void }
-    def create_graph!(packages, show_all_nodes: false)
-      graph = PackageGraph.construct
-      node_names = packages.map(&:name)
-      draw_graph!(graph, node_names, show_all_nodes: show_all_nodes)
-    end
-
-    sig { params(graph: GraphInterface, node_names: T::Array[String], show_all_nodes: T::Boolean).void }
-    def draw_graph!(graph, node_names, show_all_nodes: false)
-      # SFDP looks better than dot in some cases, but less good in other cases.
-      # If your visualization looks bad, change the layout to other_layout!
-      # https://graphviz.org/docs/layouts/
-      default_layout = :dot
-      # other_layout = :sfdp
-      graphviz_graph = GraphViz.new(
-        :G,
-        type: :digraph,
-        dpi: 100,
-        layout: default_layout,
-        label: "Visualization of #{node_names.count} packs, generated using `bin/packs`",
-        fontsize: 24,
-        labelloc: "t",
-      )
-
-      # Create graph nodes
-      graphviz_nodes = T.let({}, T::Hash[String, GraphViz::Node])
-
-      nodes_to_draw = graph.nodes.select{|n| node_names.include?(n.name) }
-
-      nodes_to_draw.each do |node|
-        graphviz_nodes[node.name] = add_node(node, graphviz_graph)
-      end
-
-      # Draw all edges
-      nodes_to_draw.each do |node|
-        node.dependencies.each do |to_node|
-          next unless node_names.include?(to_node)
-
-          add_dependency(
-            graph: graphviz_graph,
-            node1: T.must(graphviz_nodes[node.name]),
-            node2: T.must(graphviz_nodes[to_node]),
-          )
-        end
-
-        node.violations_by_node_name.each do |to_node_name, violation_count|
-          next unless node_names.include?(to_node_name)
-
-          add_violation(
-            graph: graphviz_graph,
-            node1: T.must(graphviz_nodes[node.name]),
-            node2: T.must(graphviz_nodes[to_node_name]),
-            violation_count: violation_count
-          )
-        end
-      end
-
-      add_legend(graphviz_graph)
-
-      # Save graph to filesystem
-      puts "Outputting to: #{OUTPUT_FILENAME}"
-      graphviz_graph.output(png: OUTPUT_FILENAME)
-      puts 'Finished!'
-    end
-
-    sig { params(node: NodeInterface, graph: GraphViz).returns(GraphViz::Node) }
-    def add_node(node, graph)
-      node_options = {
-        fontsize: 26.0,
-        fontcolor: 'black',
-        fillcolor: 'white',
-        color: 'black',
-        height: 1.0,
-        style: 'filled, rounded',
-        shape: 'box',
-      }
-
-      graph.add_nodes(node.name, **node_options)
-    end
-
-    sig { params(graph: GraphViz).void }
-    def add_legend(graph)
-      legend = graph.add_graph("legend")
-
-      # This commented out code was used to generate an image that I edited by hand.
-      # I was unable to figure out how to:
-      # - put a box around the legend
-      # - layout the node pairs in vertical order
-      # - give it a title
-      # So I just generated this using graphviz and then pulled the image in.
-      # a_node = legend.add_nodes("packs/a")
-      # b_node = legend.add_nodes("packs/b")
-      # c_node = legend.add_nodes("packs/c")
-      # d_node = legend.add_nodes("packs/d")
-      # e_node = legend.add_nodes("packs/e")
-      # f_node = legend.add_nodes("packs/f")
-
-      # add_dependency(graph: legend, node1: a_node, node2: b_node, label: 'Dependency in package.yml')
-      # add_violation(graph: legend, node1: c_node, node2: d_node, violation_count: 1, label: 'Violations (few)')
-      # add_violation(graph: legend, node1: e_node, node2: f_node, violation_count: 30, label: 'Violations (many)')
-
-      image = legend.add_node("",
-        shape: "image",
-        image: Pathname.new(__dir__).join("./legend.png").to_s,
-      )
-    end
-
-    sig { params(graph: GraphViz, node1: GraphViz::Node, node2: GraphViz::Node, violation_count: Integer, label: T.nilable(String)).void }
-    def add_violation(graph:, node1:, node2:, violation_count:, label: nil)
-      max_edge_width = 10
-
-      edge_width = [
-        [(violation_count / 5).to_i, 1].max, # rubocop:disable Lint/NumberConversion
-        max_edge_width,
-      ].min
-
-      opts = { color: 'red', style: 'dashed', penwidth: edge_width }
-      if label
-        opts.merge!(label: label)
-      end
-
-      graph.add_edges(node1, node2, opts)
-    end
-
-    sig { params(graph: GraphViz, node1: GraphViz::Node, node2: GraphViz::Node, label: T.nilable(String)).void }
-    def add_dependency(graph:, node1:, node2:, label: nil)
-      opts = { color: 'darkgreen' }
-      if label
-        opts.merge!(label: label)
-      end
-
-      graph.add_edges(node1, node2, opts)
-    end
-  end
-
-  private_constant :PackageRelationships
-end

data/lib/visualize_packs/team_graph.rb

@@ -1,56 +0,0 @@
-# typed: strict
-
-module VisualizePacks
-  #
-  # A team graph reduces a PackageGraph by aggregating over packages owned by teams
-  #
-  class TeamGraph
-    extend T::Sig
-    include GraphInterface
-
-    sig { override.returns(T::Set[NodeInterface]) }
-    def nodes
-      @team_nodes
-    end
-
-    sig { params(team_nodes: T::Set[TeamNode]).void }
-    def initialize(team_nodes:)
-      @team_nodes = team_nodes
-    end
-
-    sig { params(package_graph: PackageGraph).returns(TeamGraph) }
-    def self.from_package_graph(package_graph)
-      team_nodes = T.let(Set.new, T::Set[TeamNode])
-      package_graph.package_nodes.group_by(&:team_name).each do |team, package_nodes_for_team|
-        violations_by_team = {}
-        package_nodes_for_team.map(&:violations_by_package).each do |new_violations_by_package|
-          new_violations_by_package.each do |pack_name, count|
-            # We first get the pack owner of the violated package
-            other_package = package_graph.package_by_name(pack_name)
-            next if other_package.nil?
-            other_team = other_package.team_name
-            violations_by_team[other_team] ||= 0
-            # Then we add the violations on that team together
-            # TODO: We may want to ignore this if team == other_team to avoid arrows pointing to self, but maybe not!
-            violations_by_team[other_team] += count
-          end
-        end
-
-        dependencies = Set.new
-        package_nodes_for_team.map(&:dependencies).reduce(Set.new, :+).each do |dependency|
-          other_pack = package_graph.package_by_name(dependency)
-          next if other_pack.nil?
-          dependencies << other_pack.team_name
-        end
-
-        team_nodes << TeamNode.new(
-          name: team,
-          violations_by_team: violations_by_team,
-          dependencies: dependencies
-        )
-      end
-
-      TeamGraph.new(team_nodes: team_nodes)
-    end
-  end
-end

data/lib/visualize_packs/team_node.rb

@@ -1,27 +0,0 @@
-# typed: strict
-
-module VisualizePacks
-  class TeamNode < T::Struct
-    extend T::Sig
-    include NodeInterface
-
-    const :name, String
-    const :violations_by_team, T::Hash[String, Integer]
-    const :dependencies, T::Set[String]
-
-    sig { override.returns(T::Hash[String, Integer]) }
-    def violations_by_node_name
-      violations_by_team
-    end
-
-    sig { override.returns(String) }
-    def group_name
-      name
-    end
-
-    sig { override.params(node_name: String).returns(T::Boolean) }
-    def depends_on?(node_name)
-      dependencies.include?(node_name) || (violations_by_node_name[node_name] || 0) > 0
-    end
-  end
-end