packs 0.0.5 → 0.0.22

data/lib/packs/private/pack_relationship_analyzer.rb

@@ -0,0 +1,135 @@
+# typed: strict
+
+module Packs
+  module Private
+    module PackRelationshipAnalyzer
+      extend T::Sig
+
+      sig do
+        params(
+          pack_name: T.nilable(String),
+          limit: Integer
+        ).void
+      end
+      def self.list_top_privacy_violations(pack_name, limit)
+        all_packages = ParsePackwerk.all
+        if pack_name.nil?
+          to_package_names = all_packages.map(&:name)
+        else
+          pack_name = Private.clean_pack_name(pack_name)
+          package = all_packages.find { |p| p.name == pack_name }
+          if package.nil?
+            raise StandardError, "Can not find package with name #{pack_name}. Make sure the argument is of the form `packs/my_pack/`"
+          end
+
+          to_package_names = [pack_name]
+        end
+
+        violations_by_count = {}
+        total_pack_violation_count = 0
+
+        Logging.section('👋 Hi there') do
+          intro = Packs.config.user_event_logger.before_list_top_privacy_violations(pack_name, limit)
+          Logging.print_bold_green(intro)
+        end
+
+        # TODO: This is a copy of the implementation below. We may want to refactor out this implementation detail before making changes that apply to both.
+        all_packages.each do |client_package|
+          client_package.violations.select(&:privacy?).each do |violation|
+            next unless to_package_names.include?(violation.to_package_name)
+
+            if pack_name.nil?
+              violated_symbol = "#{violation.class_name} (#{violation.to_package_name})"
+            else
+              violated_symbol = violation.class_name
+            end
+            violations_by_count[violated_symbol] ||= {}
+            violations_by_count[violated_symbol][:total_count] ||= 0
+            violations_by_count[violated_symbol][:by_package] ||= {}
+            violations_by_count[violated_symbol][:by_package][client_package.name] ||= 0
+            violations_by_count[violated_symbol][:total_count] += violation.files.count
+            violations_by_count[violated_symbol][:by_package][client_package.name] += violation.files.count
+            total_pack_violation_count += violation.files.count
+          end
+        end
+
+        Logging.print("Total Count: #{total_pack_violation_count}")
+
+        sorted_violations = violations_by_count.sort_by { |violated_symbol, count_info| [-count_info[:total_count], violated_symbol] }
+        sorted_violations.first(limit).each do |violated_symbol, count_info|
+          percentage_of_total = (count_info[:total_count] * 100.0 / total_pack_violation_count).round(2)
+          Logging.print(violated_symbol)
+          Logging.print("  - Total Count: #{count_info[:total_count]} (#{percentage_of_total}% of total)")
+
+          Logging.print('  - By package:')
+          count_info[:by_package].sort_by { |client_package_name, count| [-count, client_package_name] }.each do |client_package_name, count|
+            Logging.print("    - #{client_package_name}: #{count}")
+          end
+        end
+      end
+
+      sig do
+        params(
+          pack_name: T.nilable(String),
+          limit: Integer
+        ).void
+      end
+      def self.list_top_dependency_violations(pack_name, limit)
+        all_packages = ParsePackwerk.all
+
+        if pack_name.nil?
+          to_package_names = all_packages.map(&:name)
+        else
+          pack_name = Private.clean_pack_name(pack_name)
+          package = all_packages.find { |p| p.name == pack_name }
+          if package.nil?
+            raise StandardError, "Can not find package with name #{pack_name}. Make sure the argument is of the form `packs/my_pack/`"
+          end
+
+          to_package_names = [pack_name]
+        end
+
+        Logging.section('👋 Hi there') do
+          intro = Packs.config.user_event_logger.before_list_top_dependency_violations(pack_name, limit)
+          Logging.print_bold_green(intro)
+        end
+
+        violations_by_count = {}
+        total_pack_violation_count = 0
+
+        # TODO: This is a copy of the implementation above. We may want to refactor out this implementation detail before making changes that apply to both.
+        all_packages.each do |client_package|
+          client_package.violations.select(&:dependency?).each do |violation|
+            next unless to_package_names.include?(violation.to_package_name)
+
+            if pack_name.nil?
+              violated_symbol = "#{violation.class_name} (#{violation.to_package_name})"
+            else
+              violated_symbol = violation.class_name
+            end
+            violations_by_count[violated_symbol] ||= {}
+            violations_by_count[violated_symbol][:total_count] ||= 0
+            violations_by_count[violated_symbol][:by_package] ||= {}
+            violations_by_count[violated_symbol][:by_package][client_package.name] ||= 0
+            violations_by_count[violated_symbol][:total_count] += violation.files.count
+            violations_by_count[violated_symbol][:by_package][client_package.name] += violation.files.count
+            total_pack_violation_count += violation.files.count
+          end
+        end
+
+        Logging.print("Total Count: #{total_pack_violation_count}")
+
+        sorted_violations = violations_by_count.sort_by { |violated_symbol, count_info| [-count_info[:total_count], violated_symbol] }
+        sorted_violations.first(limit).each do |violated_symbol, count_info|
+          percentage_of_total = (count_info[:total_count] * 100.0 / total_pack_violation_count).round(2)
+          Logging.print(violated_symbol)
+          Logging.print("  - Total Count: #{count_info[:total_count]} (#{percentage_of_total}% of total)")
+          Logging.print('  - By package:')
+          count_info[:by_package].sort_by { |client_package_name, count| [-count, client_package_name] }.each do |client_package_name, count|
+            Logging.print("    - #{client_package_name}: #{count}")
+          end
+        end
+      end
+    end
+  end
+end

data/lib/packs/private/packwerk_wrapper/offenses_aggregator_formatter.rb

@@ -0,0 +1,44 @@
+# typed: strict
+
+module Packs
+  module Private
+    module PackwerkWrapper
+      #
+      # This formatter simply collects offenses so we can feed them into other systems
+      #
+      class OffensesAggregatorFormatter
+        extend T::Sig
+        include Packwerk::OffensesFormatter
+
+        sig { returns(T::Array[Packwerk::ReferenceOffense]) }
+        attr_reader :aggregated_offenses
+
+        sig { void }
+        def initialize
+          @aggregated_offenses = T.let([], T::Array[Packwerk::ReferenceOffense])
+        end
+
+        sig { override.params(offenses: T::Array[T.nilable(Packwerk::Offense)]).returns(String) }
+        def show_offenses(offenses)
+          @aggregated_offenses = T.unsafe(offenses)
+          ''
+        end
+
+        sig { override.params(offense_collection: Packwerk::OffenseCollection, for_files: T::Set[String]).returns(String) }
+        def show_stale_violations(offense_collection, for_files)
+          ''
+        end
+
+        sig { override.params(strict_mode_violations: T::Array[::Packwerk::ReferenceOffense]).returns(::String) }
+        def show_strict_mode_violations(strict_mode_violations)
+          ''
+        end
+
+        sig { override.returns(::String) }
+        def identifier
+          'offenses_aggregator'
+        end
+      end
+    end
+  end
+end

data/lib/packs/private/packwerk_wrapper.rb

@@ -0,0 +1,70 @@
+# typed: strict
+
+require 'packwerk'
+require 'packs/private/packwerk_wrapper/offenses_aggregator_formatter'
+
+module Packs
+  module Private
+    module PackwerkWrapper
+      extend T::Sig
+
+      #
+      # execute_command is like `run` except it does not `exit`
+      #
+      sig { params(argv: T.untyped, formatter: T.nilable(Packwerk::OffensesFormatter)).void }
+      def self.packwerk_cli_execute_safely(argv, formatter = nil)
+        with_safe_exit_if_no_files_found do
+          packwerk_cli(formatter).execute_command(argv)
+        end
+      end
+
+      sig { params(block: T.proc.returns(T.untyped)).void }
+      def self.with_safe_exit_if_no_files_found(&block)
+        block.call
+      rescue SystemExit => e
+        # Packwerk should probably exit positively here rather than raising an error -- there should be no
+        # errors if the user has excluded all files being checked.
+        unless e.message == 'No files found or given. Specify files or check the include and exclude glob in the config file.'
+          raise
+        end
+      end
+
+      sig { params(formatter: T.nilable(Packwerk::OffensesFormatter)).returns(Packwerk::Cli) }
+      def self.packwerk_cli(formatter)
+        # This is mostly copied from exe/packwerk within the packwerk gem, but we use our own formatters
+        # Note that packwerk does not allow you to pass in your own progress formatter currently
+        ENV['RAILS_ENV'] = 'test'
+
+        style = Packwerk::OutputStyles::Coloured.new
+        Packwerk::Cli.new(style: style, offenses_formatter: formatter)
+      end
+
+      sig { params(files: T::Array[String]).returns(T::Array[Packwerk::ReferenceOffense]) }
+      def self.get_offenses_for_files(files)
+        formatter = OffensesAggregatorFormatter.new
+        packwerk_cli_execute_safely(['check', *files], formatter)
+        formatter.aggregated_offenses.compact
+      end
+
+      sig { void }
+      def self.validate!
+        formatter = OffensesAggregatorFormatter.new
+        packwerk_cli_execute_safely(['validate'], formatter)
+      end
+
+      sig { params(files: T::Array[String]).returns(T::Array[Packwerk::ReferenceOffense]) }
+      def self.get_offenses_for_files_by_package(files)
+        packages = package_names_for_files(files)
+        argv = ['check', '--packages', packages.join(',')]
+        formatter = OffensesAggregatorFormatter.new
+        packwerk_cli_execute_safely(argv, formatter)
+        formatter.aggregated_offenses.compact
+      end
+
+      sig { params(files: T::Array[String]).returns(T::Array[String]) }
+      def self.package_names_for_files(files)
+        files.map { |f| ParsePackwerk.package_from_path(f).name }.compact.uniq
+      end
+    end
+  end
+end