packwerk 2.1.0 → 2.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 66332315c1155336fbe79f8aeb6e44a0893d4100a1d4b6b5f08c81574c940fe0
-  data.tar.gz: 88da350ce07daaf7556d23edbc318a19ca33b74af71ee624d547a8a8598bc16b
+  metadata.gz: e0270de859808f51bbfa45a7140813744da0555c57d9d60432ba4e166ab63c4a
+  data.tar.gz: 90465398a3e04f83ba4c0e3b290dca72677b166003640504c7470b181e556d73
 SHA512:
-  metadata.gz: b54eeeac5e68285e03c32916d72f2afdc291d9d6d4993de0d2875d7dbb4a9cdf8cde7ca2677107f35288a20a20c1f8fc2f9ddcc330c9a7fe0dfaf8e245c07b3c
-  data.tar.gz: d8597878958e00a069cb5e51c609e04da9526b3c1933c4824399e4bad1173d718703c88ec582411a9c73fb5c88899707b04ebdb7b296a22b70e25598e11b57d6
+  metadata.gz: 86e386674412f99d605013799ebd09bbff4d9e0dd2718de534db33e71c148fd0b8aa2ec905ca96c34c48ce85e31e922eae41352c05676de8f4af6baea749c03e
+  data.tar.gz: 6406b7ddbcac8c91f3e51660d5c5e111145b6f8f01ef6ca2bfc1797cdec39b13cb0db1e3d8d04026bc59835bb67e9e8acb41a5edbd0cd207f609bbb532ffa067

data/Gemfile.lock

@@ -87,7 +87,7 @@ GIT
 PATH
   remote: .
   specs:
-    packwerk (2.1.0)
+    packwerk (2.1.1)
       activesupport (>= 5.2)
       ast
       better_html
@@ -138,14 +138,16 @@ GEM
     marcel (1.0.0)
     method_source (1.0.0)
     mini_mime (1.0.3)
-    mini_portile2 (2.6.1)
+    mini_portile2 (2.8.0)
     minitest (5.14.4)
     minitest-focus (1.2.1)
       minitest (>= 4, < 6)
     mocha (1.12.0)
     nio4r (2.5.7)
-    nokogiri (1.12.5)
-      mini_portile2 (~> 2.6.1)
+    nokogiri (1.13.3)
+      mini_portile2 (~> 2.8.0)
+      racc (~> 1.4)
+    nokogiri (1.13.3-x86_64-darwin)
       racc (~> 1.4)
     parallel (1.20.1)
     parlour (6.0.0)
@@ -159,7 +161,7 @@ GEM
       coderay (~> 1.1)
       method_source (~> 1.0)
     psych (3.3.2)
-    racc (1.5.2)
+    racc (1.6.0)
     rack (2.2.3)
     rack-test (1.1.0)
       rack (>= 1.0, < 3)
@@ -191,18 +193,19 @@ GEM
     rubocop-sorbet (0.6.1)
       rubocop
     ruby-progressbar (1.11.0)
-    smart_properties (1.16.3)
-    sorbet (0.5.6360)
-      sorbet-static (= 0.5.6360)
-    sorbet-runtime (0.5.6360)
-    sorbet-static (0.5.6360-universal-darwin-14)
-    sorbet-static (0.5.6360-universal-darwin-15)
-    sorbet-static (0.5.6360-universal-darwin-16)
-    sorbet-static (0.5.6360-universal-darwin-17)
-    sorbet-static (0.5.6360-universal-darwin-18)
-    sorbet-static (0.5.6360-universal-darwin-19)
-    sorbet-static (0.5.6360-universal-darwin-20)
-    sorbet-static (0.5.6360-x86_64-linux)
+    smart_properties (1.17.0)
+    sorbet (0.5.9538)
+      sorbet-static (= 0.5.9538)
+    sorbet-runtime (0.5.9538)
+    sorbet-static (0.5.9538-universal-darwin-14)
+    sorbet-static (0.5.9538-universal-darwin-15)
+    sorbet-static (0.5.9538-universal-darwin-16)
+    sorbet-static (0.5.9538-universal-darwin-17)
+    sorbet-static (0.5.9538-universal-darwin-18)
+    sorbet-static (0.5.9538-universal-darwin-19)
+    sorbet-static (0.5.9538-universal-darwin-20)
+    sorbet-static (0.5.9538-universal-darwin-21)
+    sorbet-static (0.5.9538-x86_64-linux)
     spoom (1.1.0)
       colorize
       sorbet (>= 0.5.6347)

data/lib/packwerk/application_validator.rb

@@ -1,4 +1,4 @@
-# typed: true
+# typed: strict
 # frozen_string_literal: true
 
 require "constant_resolver"
@@ -9,14 +9,36 @@ module Packwerk
   # Checks the structure of the application and its packwerk configuration to make sure we can run a check and deliver
   # correct results.
   class ApplicationValidator
+    extend T::Sig
+
+    sig do
+      params(
+        config_file_path: String,
+        configuration: Configuration,
+        environment: String
+      ).void
+    end
     def initialize(config_file_path:, configuration:, environment:)
       @config_file_path = config_file_path
       @configuration = configuration
       @environment = environment
+      @package_set = T.let(PackageSet.load_all_from(@configuration.root_path, package_pathspec: package_glob),
+        PackageSet)
     end
 
-    Result = Struct.new(:ok?, :error_value)
+    class Result < T::Struct
+      extend T::Sig
+
+      const :ok, T::Boolean
+      const :error_value, T.nilable(String)
+
+      sig { returns(T::Boolean) }
+      def ok?
+        ok
+      end
+    end
 
+    sig { returns(Result) }
     def check_all
       results = [
         check_package_manifests_for_privacy,
@@ -31,6 +53,7 @@ module Packwerk
       merge_results(results)
     end
 
+    sig { returns(Result) }
     def check_package_manifests_for_privacy
       privacy_settings = package_manifests_settings_for("enforce_privacy")
 
@@ -39,7 +62,7 @@ module Packwerk
         load_paths: @configuration.load_paths
       )
 
-      results = T.let([], T::Array[Packwerk::Result])
+      results = T.let([], T::Array[Result])
 
       privacy_settings.each do |config_file_path, setting|
         next unless setting.is_a?(Array)
@@ -61,6 +84,7 @@ module Packwerk
       merge_results(results, separator: "\n---\n")
     end
 
+    sig { returns(Result) }
     def check_package_manifest_syntax
       errors = []
 
@@ -102,12 +126,13 @@ module Packwerk
       end
 
       if errors.empty?
-        Result.new(true)
+        Result.new(ok: true)
       else
-        Result.new(false, errors.join("\n---\n"))
+        Result.new(ok: false, error_value: errors.join("\n---\n"))
       end
     end
 
+    sig { returns(Result) }
     def check_application_structure
       resolver = ConstantResolver.new(
         root_path: @configuration.root_path.to_s,
@@ -116,26 +141,27 @@ module Packwerk
 
       begin
         resolver.file_map
-        Result.new(true)
+        Result.new(ok: true)
       rescue => e
-        Result.new(false, e.message)
+        Result.new(ok: false, error_value: e.message)
       end
     end
 
+    sig { returns(Result) }
     def check_acyclic_graph
-      edges = package_set.flat_map do |package|
-        package.dependencies.map { |dependency| [package, package_set.fetch(dependency)] }
+      edges = @package_set.flat_map do |package|
+        package.dependencies.map { |dependency| [package, @package_set.fetch(dependency)] }
       end
-      dependency_graph = Packwerk::Graph.new(*T.unsafe(edges))
+      dependency_graph = Graph.new(*T.unsafe(edges))
 
       cycle_strings = build_cycle_strings(dependency_graph.cycles)
 
       if dependency_graph.acyclic?
-        Result.new(true)
+        Result.new(ok: true)
       else
         Result.new(
-          false,
-          <<~EOS
+          ok: false,
+          error_value: <<~EOS
             Expected the package dependency graph to be acyclic, but it contains the following cycles:
 
             #{cycle_strings.join("\n")}
@@ -144,6 +170,7 @@ module Packwerk
       end
     end
 
+    sig { returns(Result) }
     def check_package_manifest_paths
       all_package_manifests = package_manifests("**/")
       package_paths_package_manifests = package_manifests(package_glob)
@@ -151,11 +178,11 @@ module Packwerk
       difference = all_package_manifests - package_paths_package_manifests
 
       if difference.empty?
-        Result.new(true)
+        Result.new(ok: true)
       else
         Result.new(
-          false,
-          <<~EOS
+          ok: false,
+          error_value: <<~EOS
             Expected package paths for all package.ymls to be specified, but paths were missing for the following manifests:
 
             #{relative_paths(difference).join("\n")}
@@ -164,6 +191,7 @@ module Packwerk
       end
     end
 
+    sig { returns(Result) }
     def check_valid_package_dependencies
       packages_dependencies = package_manifests_settings_for("dependencies")
         .delete_if { |_, deps| deps.nil? }
@@ -175,7 +203,7 @@ module Packwerk
         end
 
       if packages_with_invalid_dependencies.empty?
-        Result.new(true)
+        Result.new(ok: true)
       else
         error_locations = packages_with_invalid_dependencies.map do |package, invalid_dependencies|
           package ||= @configuration.root_path
@@ -189,8 +217,8 @@ module Packwerk
         end
 
         Result.new(
-          false,
-          <<~EOS
+          ok: false,
+          error_value: <<~EOS
             These dependencies do not point to valid packages:
 
             #{error_locations.join("\n")}
@@ -199,16 +227,17 @@ module Packwerk
       end
     end
 
+    sig { returns(Result) }
     def check_root_package_exists
       root_package_path = File.join(@configuration.root_path, "package.yml")
       all_packages_manifests = package_manifests(package_glob)
 
       if all_packages_manifests.include?(root_package_path)
-        Result.new(true)
+        Result.new(ok: true)
       else
         Result.new(
-          false,
-          <<~EOS
+          ok: false,
+          error_value: <<~EOS
             A root package does not exist. Create an empty `package.yml` at the root directory.
           EOS
         )
@@ -224,6 +253,7 @@ module Packwerk
     # to the string:
     #
     #   ["a -> b -> c -> a", "b -> c -> b"]
+    sig { params(cycles: T.untyped).returns(T::Array[String]) }
     def build_cycle_strings(cycles)
       cycles.map do |cycle|
         cycle_strings = cycle.map(&:to_s)
@@ -232,93 +262,102 @@ module Packwerk
       end
     end
 
+    sig { params(setting: T.untyped).returns(T.untyped) }
     def package_manifests_settings_for(setting)
       package_manifests.map { |f| [f, (YAML.load_file(File.join(f)) || {})[setting]] }
     end
 
+    sig { params(list: T.untyped).returns(T.untyped) }
     def format_yaml_strings(list)
       list.sort.map { |p| "- \"#{p}\"" }.join("\n")
     end
 
+    sig { returns(T.any(T::Array[String], String)) }
     def package_glob
       @configuration.package_paths || "**"
     end
 
+    sig { params(glob_pattern: T.any(T::Array[String], String)).returns(T::Array[String]) }
     def package_manifests(glob_pattern = package_glob)
       PackageSet.package_paths(@configuration.root_path, glob_pattern, @configuration.exclude)
         .map { |f| File.realpath(f) }
     end
 
+    sig { params(paths: T::Array[String]).returns(T::Array[Pathname]) }
     def relative_paths(paths)
       paths.map { |path| relative_path(path) }
     end
 
+    sig { params(path: String).returns(Pathname) }
     def relative_path(path)
       Pathname.new(path).relative_path_from(@configuration.root_path)
     end
 
+    sig { params(path: T.untyped).returns(T::Boolean) }
     def invalid_package_path?(path)
       # Packages at the root can be implicitly specified as "."
       return false if path == "."
 
-      package_path = File.join(@configuration.root_path, path, Packwerk::PackageSet::PACKAGE_CONFIG_FILENAME)
+      package_path = File.join(@configuration.root_path, path, PackageSet::PACKAGE_CONFIG_FILENAME)
       !File.file?(package_path)
     end
 
+    sig { params(constants: T.untyped, config_file_path: String).returns(T::Array[Result]) }
     def assert_constants_can_be_loaded(constants, config_file_path)
       constants.map do |constant|
         if !constant.start_with?("::")
           Result.new(
-            false,
-            "'#{constant}', listed in the 'enforce_privacy' option in #{config_file_path}, is invalid.\n"\
+            ok: false,
+            error_value: "'#{constant}', listed in the 'enforce_privacy' option in #{config_file_path}, is invalid.\n"\
             "Private constants need to be prefixed with the top-level namespace operator `::`."
           )
         else
-          constant.try(&:constantize) && Result.new(true)
+          constant.try(&:constantize) && Result.new(ok: true)
         end
       end
     end
 
+    sig { params(name: T.untyped, config_file_path: T.untyped).returns(Result) }
     def private_constant_unresolvable(name, config_file_path)
       explicit_filepath = (name.start_with?("::") ? name[2..-1] : name).underscore + ".rb"
 
       Result.new(
-        false,
-        "'#{name}', listed in #{config_file_path}, could not be resolved.\n"\
+        ok: false,
+        error_value: "'#{name}', listed in #{config_file_path}, could not be resolved.\n"\
         "This is probably because it is an autovivified namespace - a namespace module that doesn't have a\n"\
         "file explicitly defining it. Packwerk currently doesn't support declaring autovivified namespaces as\n"\
         "private. Add a #{explicit_filepath} file to explicitly define the constant."
       )
     end
 
+    sig { params(name: T.untyped, location: T.untyped, config_file_path: T.untyped).returns(Result) }
     def check_private_constant_location(name, location, config_file_path)
-      declared_package = package_set.package_from_path(relative_path(config_file_path))
-      constant_package = package_set.package_from_path(location)
+      declared_package = @package_set.package_from_path(relative_path(config_file_path))
+      constant_package = @package_set.package_from_path(location)
 
       if constant_package == declared_package
-        Result.new(true)
+        Result.new(ok: true)
       else
         Result.new(
-          false,
-          "'#{name}' is declared as private in the '#{declared_package}' package but appears to be "\
+          ok: false,
+          error_value: "'#{name}' is declared as private in the '#{declared_package}' package but appears to be "\
           "defined\nin the '#{constant_package}' package. Packwerk resolved it to #{location}."
         )
       end
     end
 
-    def package_set
-      @package_set ||= Packwerk::PackageSet.load_all_from(@configuration.root_path, package_pathspec: package_glob)
+    sig do
+      params(results: T::Array[Result], separator: String, errors_headline: String).returns(Result)
     end
-
     def merge_results(results, separator: "\n===\n", errors_headline: "")
       results.reject!(&:ok?)
 
       if results.empty?
-        Result.new(true)
+        Result.new(ok: true)
       else
         Result.new(
-          false,
-          errors_headline + results.map(&:error_value).join(separator)
+          ok: false,
+          error_value: errors_headline + results.map(&:error_value).join(separator)
         )
       end
     end

data/lib/packwerk/cache.rb

@@ -44,7 +44,7 @@ module Packwerk
       ]
     end
 
-    sig { params(enable_cache: T::Boolean, cache_directory: Pathname, config_path: String).void }
+    sig { params(enable_cache: T::Boolean, cache_directory: Pathname, config_path: T.nilable(String)).void }
     def initialize(enable_cache:, cache_directory:, config_path:)
       @enable_cache = enable_cache
       @cache = T.let({}, CACHE_SHAPE)
@@ -115,6 +115,7 @@ module Packwerk
 
     sig { void }
     def bust_cache_if_packwerk_yml_has_changed!
+      return nil if @config_path.nil?
       bust_cache_if_contents_have_changed(File.read(@config_path), :packwerk_yml)
     end
 

data/lib/packwerk/cli.rb

@@ -1,4 +1,4 @@
-# typed: true
+# typed: strict
 # frozen_string_literal: true
 
 require "optparse"
@@ -30,9 +30,10 @@ module Packwerk
       @err_out = err_out
       @environment = environment
       @style = style
-      @configuration = configuration || Configuration.from_path
-      @progress_formatter = Formatters::ProgressFormatter.new(@out, style: style)
-      @offenses_formatter = offenses_formatter || Formatters::OffensesFormatter.new(style: @style)
+      @configuration = T.let(configuration || Configuration.from_path, Configuration)
+      @progress_formatter = T.let(Formatters::ProgressFormatter.new(@out, style: style), Formatters::ProgressFormatter)
+      @offenses_formatter = T.let(offenses_formatter || Formatters::OffensesFormatter.new(style: @style),
+        OffensesFormatter)
     end
 
     sig { params(args: T::Array[String]).returns(T.noreturn) }
@@ -78,12 +79,14 @@ module Packwerk
 
     private
 
+    sig { returns(T::Boolean) }
     def init
       @out.puts("📦 Initializing Packwerk...")
 
       generate_configs
     end
 
+    sig { returns(T::Boolean) }
     def generate_configs
       configuration_file = Packwerk::Generators::ConfigurationFile.generate(
         root: @configuration.root_path,
@@ -112,23 +115,26 @@ module Packwerk
       success
     end
 
+    sig { params(result: Result).returns(T::Boolean) }
     def output_result(result)
       @out.puts
       @out.puts(result.message)
       result.status
     end
 
-    def fetch_files_to_process(paths, ignore_nested_packages)
-      files = FilesForProcessing.fetch(
-        paths: paths,
+    sig { params(relative_file_paths: T::Array[String], ignore_nested_packages: T::Boolean).returns(T::Array[String]) }
+    def fetch_files_to_process(relative_file_paths, ignore_nested_packages)
+      absolute_files = FilesForProcessing.fetch(
+        relative_file_paths: relative_file_paths,
         ignore_nested_packages: ignore_nested_packages,
         configuration: @configuration
       )
       abort("No files found or given. "\
-        "Specify files or check the include and exclude glob in the config file.") if files.empty?
-      files
+        "Specify files or check the include and exclude glob in the config file.") if absolute_files.empty?
+      absolute_files
     end
 
+    sig { params(_paths: T::Array[String]).returns(T::Boolean) }
     def validate(_paths)
       @progress_formatter.started_validation do
         result = checker.check_all
@@ -139,6 +145,7 @@ module Packwerk
       end
     end
 
+    sig { returns(ApplicationValidator) }
     def checker
       Packwerk::ApplicationValidator.new(
         config_file_path: @configuration.config_path,
@@ -147,6 +154,7 @@ module Packwerk
       )
     end
 
+    sig { params(result: ApplicationValidator::Result).void }
     def list_validation_errors(result)
       @out.puts
       if result.ok?
@@ -157,24 +165,25 @@ module Packwerk
       end
     end
 
+    sig { params(params: T.untyped).returns(ParseRun) }
     def parse_run(params)
-      paths = T.let([], T::Array[String])
+      relative_file_paths = T.let([], T::Array[String])
       ignore_nested_packages = nil
 
       if params.any? { |p| p.include?("--packages") }
         OptionParser.new do |parser|
           parser.on("--packages=PACKAGESLIST", Array, "package names, comma separated") do |p|
-            paths = p
+            relative_file_paths = p
           end
         end.parse!(params)
         ignore_nested_packages = true
       else
-        paths = params
+        relative_file_paths = params
         ignore_nested_packages = false
       end
 
       ParseRun.new(
-        files: fetch_files_to_process(paths, ignore_nested_packages),
+        absolute_files: fetch_files_to_process(relative_file_paths, ignore_nested_packages),
         configuration: @configuration,
         progress_formatter: @progress_formatter,
         offenses_formatter: @offenses_formatter

data/lib/packwerk/constant_discovery.rb

@@ -15,10 +15,15 @@ module Packwerk
   #   have no way of inferring the file it is defined in. You could argue though that inheritance means that another
   #   constant with the same name exists in the inheriting class, and this view is sufficient for all our use cases.
   class ConstantDiscovery
+    extend T::Sig
+
     ConstantContext = Struct.new(:name, :location, :package, :public?)
 
     # @param constant_resolver [ConstantResolver]
     # @param packages [Packwerk::PackageSet]
+    sig do
+      params(constant_resolver: ConstantResolver, packages: Packwerk::PackageSet).void
+    end
     def initialize(constant_resolver:, packages:)
       @packages = packages
       @resolver = constant_resolver
@@ -30,6 +35,11 @@ module Packwerk
     #
     # @return [Packwerk::Package] the package that contains the given file,
     #   or nil if the path is not owned by any component
+    sig do
+      params(
+        path: String,
+      ).returns(Packwerk::Package)
+    end
     def package_from_path(path)
       @packages.package_from_path(path)
     end
@@ -41,6 +51,12 @@ module Packwerk
     # @param current_namespace_path [Array<String>] (optional) The namespace of the context in which the constant is
     #   used, e.g. ["Apps", "Models"] for `Apps::Models`. Defaults to [] which means top level.
     # @return [Packwerk::ConstantDiscovery::ConstantContext]
+    sig do
+      params(
+        const_name: String,
+        current_namespace_path: T.nilable(T::Array[String]),
+      ).returns(T.nilable(ConstantDiscovery::ConstantContext))
+    end
     def context_for(const_name, current_namespace_path: [])
       begin
         constant = @resolver.resolve(const_name, current_namespace_path: current_namespace_path)
@@ -55,7 +71,7 @@ module Packwerk
         constant.name,
         constant.location,
         package,
-        package&.public_path?(constant.location),
+        package.public_path?(constant.location),
       )
     end
   end

data/lib/packwerk/constant_name_inspector.rb

@@ -1,4 +1,4 @@
-# typed: true
+# typed: strict
 # frozen_string_literal: true
 
 require "ast"

data/lib/packwerk/file_processor.rb

@@ -1,4 +1,4 @@
-# typed: true
+# typed: strict
 # frozen_string_literal: true
 
 require "ast/node"
@@ -8,6 +8,9 @@ module Packwerk
     extend T::Sig
 
     class UnknownFileTypeResult < Offense
+      extend T::Sig
+
+      sig { params(file: String).void }
       def initialize(file:)
         super(file: file, message: "unknown file type")
       end
@@ -23,11 +26,11 @@ module Packwerk
     def initialize(node_processor_factory:, cache:, parser_factory: nil)
       @node_processor_factory = node_processor_factory
       @cache = cache
-      @parser_factory = parser_factory || Packwerk::Parsers::Factory.instance
+      @parser_factory = T.let(parser_factory || Packwerk::Parsers::Factory.instance, Parsers::Factory)
     end
 
     sig do
-      params(file_path: String).returns(
+      params(absolute_file: String).returns(
         T::Array[
           T.any(
             Packwerk::UnresolvedReference,
@@ -36,15 +39,15 @@ module Packwerk
         ]
       )
     end
-    def call(file_path)
-      return [UnknownFileTypeResult.new(file: file_path)] if parser_for(file_path).nil?
-
-      @cache.with_cache(file_path) do
-        node = parse_into_ast(file_path)
+    def call(absolute_file)
+      parser = parser_for(absolute_file)
+      return [UnknownFileTypeResult.new(file: absolute_file)] if T.unsafe(parser).nil?
 
+      @cache.with_cache(absolute_file) do
+        node = parse_into_ast(absolute_file, T.must(parser))
         return [] unless node
 
-        references_from_ast(node, file_path)
+        references_from_ast(node, absolute_file)
       end
     rescue Parsers::ParseError => e
       [e.result]
@@ -53,24 +56,26 @@ module Packwerk
     private
 
     sig do
-      params(node: Parser::AST::Node, file_path: String).returns(T::Array[UnresolvedReference])
+      params(node: Parser::AST::Node, absolute_file: String).returns(T::Array[UnresolvedReference])
     end
-    def references_from_ast(node, file_path)
+    def references_from_ast(node, absolute_file)
       references = []
 
-      node_processor = @node_processor_factory.for(filename: file_path, node: node)
+      node_processor = @node_processor_factory.for(absolute_file: absolute_file, node: node)
       node_visitor = Packwerk::NodeVisitor.new(node_processor: node_processor)
       node_visitor.visit(node, ancestors: [], result: references)
 
       references
     end
 
-    def parse_into_ast(file_path)
-      File.open(file_path, "r", nil, external_encoding: Encoding::UTF_8) do |file|
-        parser_for(file_path).call(io: file, file_path: file_path)
+    sig { params(absolute_file: String, parser: Parsers::ParserInterface).returns(T.untyped) }
+    def parse_into_ast(absolute_file, parser)
+      File.open(absolute_file, "r", nil, external_encoding: Encoding::UTF_8) do |file|
+        parser.call(io: file, file_path: absolute_file)
       end
     end
 
+    sig { params(file_path: String).returns(T.nilable(Parsers::ParserInterface)) }
     def parser_for(file_path)
       @parser_factory.for_path(file_path)
     end