visualize_packs 0.5.10 → 0.5.12

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 93422667173f599ef3700a5a98451ea6fc00ae8269544e6b66138034fc743f22
-  data.tar.gz: 9c238ea399cfcd9426f6de268a9b25796ac04995c39bd7ace459961a7e21d502
+  metadata.gz: 8017d316d5d179efe32200f2152bb0abb1c8a3b3299ba8f777a604c07165660e
+  data.tar.gz: 5f306bd08bdc5cb70eee69ea23a9233ba03ad8d13bd7c6c75c92a39a18f3f1f6
 SHA512:
-  metadata.gz: 556726fd4072b0426afa6c7e65271dc06d25f159d70c44245b5058bac0543fbfde80e0cfa205046b02428b856c0ecc2926828c85eb4988f9378b2e8dce5c609b
-  data.tar.gz: c4d7c4fc2a64f278e9b5e6fae2afce66c1729eb47617807de29f7b6b7518ec091cb4da8a83ac6b945ecbb45b5bf2b2910e839c39c10d8dee3ab69dc817724605
+  metadata.gz: e9c0773394b6f17466e75e00c825dfcca7a1d359922988b257a08e59fb1ce76e2c373cfe968783d87f3ec8da5b9f500d53d64dcfc74946a3ac804376e22bdeb3
+  data.tar.gz: aff8ae19a21ca89a91331c2c2679fc64e15c5151e5f59a72a7dc35b7d5df72680e0627d6462ec6b5cc519098263210c60994445a563fc6aa95149be7a4d4c684

data/README.md

@@ -48,3 +48,5 @@ Once you are ready, run the following and commit the new `diagram_examples.png`
 ```
 ./spec/update_cassettes.sh
 ```
+
+Please check in a new `diagram_examples.png` only if there are actual visual changes.

data/bin/visualize_packs

@@ -32,12 +32,12 @@ OptionParser.new do |opt|
   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', "Focus on a specific package") { |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('--focus-folder=FOLDER', "Draw package diagram only for packages in FOLDER. Matches with 'include' for partial matches") { |o| options.focus_folder = o.empty? ? nil : o }
+  opt.on('--focus-pack=pack1,pack2', "Focus on a specific package(s). Wildcards support: 'packs/*'") { |o| options.focus_pack = o.to_s.split(",") }
+  opt.on('--only-edges-to-focus=[in,out,inout]', "If focus-pack is set, this shows only the edges into / out of / in and out of the focus node instead of all edges in the focussed graph.") { |o| options.show_only_edges_to_focus_pack = FocusPackEdgeDirection.deserialize(o) }
 
   opt.on('--roll-nested-into-parent-packs', "Don't show nested packages (not counting root). Connect edges to top-level package instead") { |o| options.roll_nested_into_parent_packs = 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 relationships between parents and nested packs") { |o| options.show_nested_relationships = false }
+  opt.on('--no-nested-relationships', "Don't draw relationships between parents and nested packs") { |o| options.show_nested_relationships = false }
 
   opt.on('--exclude-packs=pack1,pack2,etc', "Exclude listed packs from diagram. If used with include you will get all included that are not excluded. Wildcards support: 'packs/ignores/*'") { |o| options.exclude_packs = o.to_s.split(",") }
   opt.on('--include-packs=pack1,pack2,etc', "Include only listed packs in diagram. If used with exclude you will get all included that are not excluded. Wildcards support: 'packs/ignores/*'") { |o| options.include_packs = o.to_s.split(",") }

data/lib/graph.dot.erb

@@ -33,7 +33,7 @@ digraph package_diagram {
       <%- end -%>
       <%- grouped_packages[layer_name].each do |package| -%>
         "<%= package.name -%>" [
-            fontsize=<%= options.focus_package && package.name == options.focus_package ? 18.0 : 12.0 -%>
+            fontsize=<%= options.focus_pack.any? && options.focus_pack.any? {|p| File.fnmatch(p, package.name)} ? 18.0 : 12.0 -%>
             <%- if options.remote_base_url %>
               URL="<%= options.remote_base_url %>/<%= package.name == '.' ? '' : package.name -%>"
             <%- end %>

data/lib/options.rb

@@ -1,6 +1,14 @@
 # frozen_string_literal: true
 # typed: strict
 
+class FocusPackEdgeDirection < T::Enum
+  enums do
+    In = new
+    Out = new
+    InOut = new
+  end
+end
+
 class Options < T::Struct
   extend T::Sig
 
@@ -12,11 +20,11 @@ class Options < T::Struct
   prop :show_privacy, T::Boolean, default: true
   prop :show_teams, T::Boolean, default: true
 
-  prop :focus_package, T.nilable(String)
-  prop :show_only_edges_to_focus_package, T::Boolean, default: false
+  prop :focus_folder, T.nilable(String)
+  prop :focus_pack, T::Array[String], default: []
+  prop :show_only_edges_to_focus_pack, T.nilable(FocusPackEdgeDirection), default: nil
 
   prop :roll_nested_into_parent_packs, T::Boolean, default: false
-  prop :focus_folder, T.nilable(String)
   prop :show_nested_relationships, T::Boolean, default: true
 
   prop :exclude_packs, T::Array[String], default: []

data/lib/visualize_packs.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
-# typed: false
+# typed: strict
 
 require 'erb'
 require 'packs-specification'
@@ -7,14 +7,14 @@ require 'parse_packwerk'
 require 'digest/md5'
 
 module VisualizePacks
+  extend T::Sig
 
+  sig { params(options: Options, raw_config: T::Hash[String, T.untyped], packages: T::Array[ParsePackwerk::Package]).returns(String) }
   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, options.include_packs, options.exclude_packs).sort_by {|x| x.name }
+    all_packages = filtered(packages, options).compact.sort_by {|x| x.name }
     all_package_names = all_packages.map &:name
 
-    all_packages = remove_nested_packs(all_packages) if options.roll_nested_into_parent_packs
+    all_packages = remove_nested_packs(all_packages, options)
 
     show_edge = show_edge_builder(options, all_package_names)
     node_color = node_color_builder()
@@ -48,14 +48,16 @@ module VisualizePacks
 
   private 
 
+  sig { params(package: ParsePackwerk::Package).returns(T.nilable(String)) }
   def self.code_owner(package)
     package.config.dig("metadata", "owner") || package.config["owner"]
   end
 
+  sig { params(options: Options, max_todo_count: T.nilable(Integer)).returns(String) }
   def self.diagram_title(options, max_todo_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"
+    focus_edge_info = options.focus_pack.any? && options.show_only_edges_to_focus_pack ? "showing only edges to/from focus pack" : "showing all edges between visible packs"
+    focus_info = options.focus_pack.any? || options.focus_folder ? "Focus on #{[limited_sentence(options.focus_pack), options.focus_folder].compact.join(' and ')} (#{focus_edge_info})" : "All packs"
     skipped_info = 
     [
       options.show_legend ? nil : "hiding legend",
@@ -78,30 +80,44 @@ module VisualizePacks
     "<<b>#{main_title}</b>#{sub_title}>"
   end
 
+  sig { params(list: T.nilable(T::Array[String])).returns(T.nilable(String)) }
   def self.limited_sentence(list)
+    return nil if !list || list.empty?
+
     if list.size <= 2
       list.join(" and ")
     else
-      "#{list[0, 2].join(", ")}, and #{list.size - 2} more"
+      "#{T.must(list[0, 2]).join(", ")}, and #{list.size - 2} more"
     end
   end
 
+  sig { params(options: Options, all_package_names: T::Array[String]).returns(T.proc.params(arg0: String, arg1: String).returns(T::Boolean)) }
   def self.show_edge_builder(options, all_package_names)
     return lambda do |start_node, end_node|
       (
-        !options.show_only_edges_to_focus_package && 
+        !options.show_only_edges_to_focus_pack && 
         all_package_names.include?(start_node) && 
         all_package_names.include?(end_node)
       ) ||
       (
-        options.show_only_edges_to_focus_package && 
+        options.show_only_edges_to_focus_pack && 
         all_package_names.include?(start_node) && 
         all_package_names.include?(end_node) && 
-        [start_node, end_node].include?(options.focus_package)
+        (
+          case options.show_only_edges_to_focus_pack
+          when FocusPackEdgeDirection::InOut then
+            match_packs?(start_node, options.focus_pack) || match_packs?(end_node, options.focus_pack)
+          when FocusPackEdgeDirection::In then
+            match_packs?(end_node, options.focus_pack)
+          when FocusPackEdgeDirection::Out then
+            match_packs?(start_node, options.focus_pack)
+          end
+        )
       )
     end
   end
 
+  sig { returns(T.nilable(T.proc.params(arg0: String).returns(String))) }
   def self.node_color_builder
     return lambda do |text|
       return unless text
@@ -114,17 +130,17 @@ module VisualizePacks
     end
   end
 
+  sig { params(all_packages: T::Array[ParsePackwerk::Package], show_edge: T.proc.params(arg0: String, arg1: String).returns(T::Boolean)).returns(T.nilable(Integer)) }
   def self.max_todo_count(all_packages, show_edge)
     todo_counts = {}
     all_packages.each do |package|
-      todos_by_package = package.violations.group_by(&:to_package_name)
-      todos_by_package.keys.each do |todos_to_package|
-        todo_types = todos_by_package[todos_to_package].group_by(&:type)
-        todo_types.keys.each do |todo_type|
+      todos_by_package = package.violations&.group_by(&:to_package_name)
+      todos_by_package&.keys&.each do |todos_to_package|
+        todo_types = todos_by_package&& todos_by_package[todos_to_package]&.group_by(&:type)
+        todo_types&.keys&.each do |todo_type|
           if show_edge.call(package.name, todos_to_package)
             key = "#{package.name}->#{todos_to_package}:#{todo_type}"
-            todo_counts[key] = todo_types[todo_type].count
-            # todo_counts[key] += 1
+            todo_counts[key] = todo_types && todo_types[todo_type]&.count
           end
         end
       end
@@ -132,6 +148,7 @@ module VisualizePacks
     todo_counts.values.max
   end
 
+  sig { params(todo_count: Integer, max_count: Integer).returns(T.any(Float, Integer)) }
   def self.todo_edge_width(todo_count, max_count)
     # Limits
     min_width = 1
@@ -151,22 +168,44 @@ module VisualizePacks
     edge_width.round(2)
  end
 
-  def self.filtered(packages, filter_package, filter_folder, include_packs, exclude_packs)
-    return packages unless filter_package || filter_folder || include_packs || exclude_packs.any?
+ sig { params(packages: T::Array[ParsePackwerk::Package], options: Options).returns(T::Array[ParsePackwerk::Package]) }
+ def self.filtered(packages, options)
+    focus_pack = options.focus_pack
+    focus_folder = options.focus_folder 
+    include_packs = options.include_packs 
+    exclude_packs = options.exclude_packs
+
+    return packages unless focus_pack.any? || focus_folder || include_packs || exclude_packs.any?
 
+    nested_packages = all_nested_packages(packages.map { |p| p.name })
+
+    packages_by_name = packages.inject({}) do |res, p|
+      res[p.name] = p
+      res
+    end
+ 
+    result = T.let([], T::Array[T.nilable(String)])
     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)
+    if !focus_pack.empty?
+      result = []
+      result += packages.map { |pack| pack.name }.select { |p| match_packs?(p, focus_pack) }
+      result += packages.select{ |p| p.dependencies.any? { |d| match_packs?(d, focus_pack) }}.map { |pack| pack.name }
+      result += packages.select{ |p| p.violations&.map(&:to_package_name)&.any? { |v| match_packs?(v, focus_pack) }}.map { |pack| pack.name }
+      packages.map { |pack| pack.name }.select { |p| match_packs?(p, focus_pack) }.each do |p|
+        result += packages_by_name[p].dependencies
+        result += packages_by_name[p].violations.map(&:to_package_name)
+      end
       result = result.uniq
+      parent_packs = result.inject([]) do |res, package_name|
+        res << nested_packages[package_name]
+        res
+      end
+      result = (result + parent_packs).uniq.compact
     end
 
-    if filter_folder
-      result = result.select { |p| p.include? filter_folder }
+    if focus_folder
+      result = result.select { |p| p.include? focus_folder }
     end
 
     if include_packs
@@ -177,9 +216,10 @@ module VisualizePacks
       result = result.reject { |p| match_packs?(p, exclude_packs) }
     end
 
-    result.map { |pack_name| ParsePackwerk.find(pack_name) }
+    result.map { |pack_name| packages_by_name[pack_name] }
   end
 
+  sig { params(all_package_names: T::Array[String]).returns(T::Hash[String, String]) }
   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) }
@@ -193,7 +233,10 @@ module VisualizePacks
     end
   end
 
-  def self.remove_nested_packs(packages)
+  sig { params(packages: T::Array[ParsePackwerk::Package], options: Options).returns(T::Array[ParsePackwerk::Package]) }
+  def self.remove_nested_packs(packages, options)
+    return packages unless options.roll_nested_into_parent_packs
+
     nested_packages = all_nested_packages(packages.map { |p| p.name })
 
     # top-level packages
@@ -212,9 +255,9 @@ module VisualizePacks
               enforce_privacy: package.enforce_privacy,
               public_path: package.public_path,
               metadata: package.metadata,
-              dependencies: package.dependencies + nested_package.dependencies,
+              dependencies: package.dependencies + T.must(nested_package).dependencies,
               config: package.config,
-              violations: package.violations + nested_package.violations
+              violations: T.must(package.violations) + T.must(T.must(nested_package).violations)
             )
           end
         end
@@ -224,7 +267,7 @@ module VisualizePacks
           nested_packages[d] || d
         end.uniq.reject { |p| p == package.name }
 
-        morphed_todos = package.violations.map do |v|
+        morphed_todos = T.must(package.violations).map do |v|
           ParsePackwerk::Violation.new(
             type: v.type, 
             to_package_name: nested_packages[v.to_package_name] || v.to_package_name, 
@@ -244,15 +287,14 @@ module VisualizePacks
           config: package.config,
           violations: morphed_todos
         )
-        # add dependencies TO nested packages to top-level package
-        # add todos TO nested packages to top-level package
       end
     end
 
     morphed_packages.reject { |p| nested_packages.keys.include?(p.name) }
   end
 
-  def self.match_packs?(pack, packs)
-    packs.any? {|p| File.fnmatch(p, pack)}
+  sig { params(pack: String, packs_name_with_wildcards: T::Array[String]).returns(T::Boolean) }
+  def self.match_packs?(pack, packs_name_with_wildcards)
+    packs_name_with_wildcards.any? {|p| File.fnmatch(p, pack)}
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: visualize_packs
 version: !ruby/object:Gem::Version
-  version: 0.5.10
+  version: 0.5.12
 platform: ruby
 authors:
 - Gusto Engineers
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2023-09-01 00:00:00.000000000 Z
+date: 2023-09-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler