packwerk 2.3.0 → 3.0.1

data/lib/packwerk/spring_command.rb

@@ -1,24 +1,31 @@
-# typed: true
+# typed: strict
 # frozen_string_literal: true
 
 require "spring/commands"
+require "sorbet-runtime"
 
 module Packwerk
   class SpringCommand
-    def env(*)
+    extend T::Sig
+
+    sig { params(args: T.untyped).returns(String) }
+    def env(args)
       # Packwerk needs to run in a test environment, which has a set of autoload paths that are
       # often a superset of the dev/prod paths (for example, test/support/helpers)
       "test"
     end
 
+    sig { returns(String) }
     def exec_name
       "packwerk"
     end
 
+    sig { returns(String) }
     def gem_name
       "packwerk"
     end
 
+    sig { returns(T::Boolean) }
     def call
       load(Gem.bin_path(gem_name, exec_name))
     end

data/lib/packwerk/unresolved_reference.rb

@@ -6,5 +6,13 @@ module Packwerk
   # Unresolved means that we know how it's referred to in the file,
   # and we have enough context on that reference to figure out the fully qualified reference such that we
   # can produce a Reference in a separate pass. However, we have not yet resolved it to its fully qualified version.
-  UnresolvedReference = Struct.new(:constant_name, :namespace_path, :relative_path, :source_location)
+  UnresolvedReference = Struct.new(
+    :constant_name,
+    :namespace_path,
+    :relative_path,
+    :source_location,
+    keyword_init: true,
+  )
+
+  private_constant :UnresolvedReference
 end

data/lib/packwerk/validator/result.rb

@@ -0,0 +1,18 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Packwerk
+  module Validator
+    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
+  end
+end

data/lib/packwerk/validator.rb

@@ -0,0 +1,90 @@
+# typed: strict
+# frozen_string_literal: true
+
+require "constant_resolver"
+require "pathname"
+require "yaml"
+
+module Packwerk
+  module Validator
+    extend T::Sig
+    extend T::Helpers
+
+    abstract!
+
+    class << self
+      extend T::Sig
+
+      sig { params(base: Class).void }
+      def included(base)
+        @validators ||= T.let(@validators, T.nilable(T::Array[Class]))
+        @validators ||= []
+        @validators << base
+      end
+
+      sig { returns(T::Array[Validator]) }
+      def all
+        T.unsafe(@validators).map(&:new)
+      end
+    end
+
+    sig { abstract.returns(T::Array[String]) }
+    def permitted_keys
+    end
+
+    sig { abstract.params(package_set: PackageSet, configuration: Configuration).returns(Validator::Result) }
+    def call(package_set, configuration)
+    end
+
+    sig { params(configuration: Configuration, setting: T.untyped).returns(T.untyped) }
+    def package_manifests_settings_for(configuration, setting)
+      package_manifests(configuration).map { |f| [f, (YAML.load_file(File.join(f)) || {})[setting]] }
+    end
+
+    sig do
+      params(configuration: Configuration,
+        glob_pattern: T.nilable(T.any(T::Array[String], String))).returns(T::Array[String])
+    end
+    def package_manifests(configuration, glob_pattern = nil)
+      glob_pattern ||= package_glob(configuration)
+      PackageSet.package_paths(configuration.root_path, glob_pattern, configuration.exclude)
+        .map { |f| File.realpath(f) }
+    end
+
+    sig { params(configuration: Configuration).returns(T.any(T::Array[String], String)) }
+    def package_glob(configuration)
+      configuration.package_paths
+    end
+
+    sig do
+      params(
+        results: T::Array[Validator::Result],
+        separator: String,
+        before_errors: String,
+        after_errors: String,
+      ).returns(Validator::Result)
+    end
+    def merge_results(results, separator: "\n", before_errors: "", after_errors: "")
+      results.reject!(&:ok?)
+
+      if results.empty?
+        Validator::Result.new(ok: true)
+      else
+        Validator::Result.new(
+          ok: false,
+          error_value: [
+            before_errors,
+            separator.lstrip,
+            results.map(&:error_value).join(separator),
+            after_errors,
+          ].join,
+        )
+      end
+    end
+
+    sig { params(configuration: Configuration, path: String).returns(Pathname) }
+    def relative_path(configuration, path)
+      Pathname.new(path).relative_path_from(configuration.root_path)
+    end
+  end
+end

data/lib/packwerk/validators/dependency_validator.rb

@@ -0,0 +1,154 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Packwerk
+  module Validators
+    class DependencyValidator
+      extend T::Sig
+      include Validator
+
+      sig do
+        override.params(package_set: PackageSet, configuration: Configuration).returns(Validator::Result)
+      end
+      def call(package_set, configuration)
+        results = [
+          check_package_manifest_syntax(configuration),
+          check_acyclic_graph(package_set),
+          check_valid_package_dependencies(configuration),
+        ]
+
+        merge_results(results)
+      end
+
+      sig { override.returns(T::Array[String]) }
+      def permitted_keys
+        [
+          "enforce_dependencies",
+          "dependencies",
+        ]
+      end
+
+      private
+
+      sig { params(configuration: Configuration).returns(Validator::Result) }
+      def check_package_manifest_syntax(configuration)
+        errors = []
+
+        valid_settings = [true, false, "strict"]
+        package_manifests_settings_for(configuration, "enforce_dependencies").each do |config, setting|
+          next if setting.nil?
+
+          unless valid_settings.include?(setting)
+            errors << "\tInvalid 'enforce_dependencies' option: #{setting.inspect} in #{config.inspect}"
+          end
+        end
+
+        package_manifests_settings_for(configuration, "dependencies").each do |config, setting|
+          next if setting.nil?
+
+          unless setting.is_a?(Array)
+            errors << "\tInvalid 'dependencies' option: #{setting.inspect} in #{config.inspect}"
+          end
+        end
+
+        if errors.empty?
+          Validator::Result.new(ok: true)
+        else
+          merge_results(
+            errors.map { |error| Validator::Result.new(ok: false, error_value: error) },
+            separator: "\n",
+            before_errors: "Malformed syntax in the following manifests:\n\n",
+            after_errors: "\n",
+          )
+        end
+      end
+
+      sig { params(package_set: PackageSet).returns(Validator::Result) }
+      def check_acyclic_graph(package_set)
+        edges = package_set.flat_map do |package|
+          package.dependencies.map do |dependency|
+            [package.name, package_set.fetch(dependency)&.name]
+          end
+        end
+
+        dependency_graph = Graph.new(edges)
+
+        cycle_strings = build_cycle_strings(dependency_graph.cycles)
+
+        if dependency_graph.acyclic?
+          Validator::Result.new(ok: true)
+        else
+          Validator::Result.new(
+            ok: false,
+            error_value: <<~EOS
+              Expected the package dependency graph to be acyclic, but it contains the following circular dependencies:
+
+              #{cycle_strings.join("\n")}
+            EOS
+          )
+        end
+      end
+
+      sig { params(configuration: Configuration).returns(Validator::Result) }
+      def check_valid_package_dependencies(configuration)
+        packages_dependencies = package_manifests_settings_for(configuration, "dependencies")
+          .delete_if { |_, deps| deps.nil? }
+
+        packages_with_invalid_dependencies =
+          packages_dependencies.each_with_object([]) do |(package, dependencies), invalid_packages|
+            invalid_dependencies = if dependencies.is_a?(Array)
+              dependencies.filter { |path| invalid_package_path?(configuration, path) }
+            else
+              []
+            end
+            invalid_packages << [package, invalid_dependencies] if invalid_dependencies.any?
+          end
+
+        if packages_with_invalid_dependencies.empty?
+          Validator::Result.new(ok: true)
+        else
+          error_locations = packages_with_invalid_dependencies.map do |package, invalid_dependencies|
+            package ||= configuration.root_path
+            package_path = Pathname.new(package).relative_path_from(configuration.root_path)
+            all_invalid_dependencies = invalid_dependencies.map { |d| "  - #{d}" }
+
+            <<~EOS
+              \t#{package_path}:
+              \t#{all_invalid_dependencies.join("\n\t")}
+            EOS
+          end
+
+          Validator::Result.new(
+            ok: false,
+            error_value: "These dependencies do not point to valid packages:\n\n#{error_locations.join("\n")}"
+          )
+        end
+      end
+
+      sig { params(configuration: Configuration, path: T.untyped).returns(T::Boolean) }
+      def invalid_package_path?(configuration, path)
+        # Packages at the root can be implicitly specified as "."
+        return false if path == "."
+
+        package_path = File.join(configuration.root_path, path, PackageSet::PACKAGE_CONFIG_FILENAME)
+        !File.file?(package_path)
+      end
+
+      # Convert the cycles:
+      #
+      #   [[a, b, c], [b, c]]
+      #
+      # 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)
+          cycle_strings << cycle.first.to_s
+          "\t- #{cycle_strings.join(" → ")}"
+        end
+      end
+    end
+  end
+end

data/lib/packwerk/version.rb

@@ -2,5 +2,5 @@
 # frozen_string_literal: true
 
 module Packwerk
-  VERSION = "2.3.0"
+  VERSION = "3.0.1"
 end

data/lib/packwerk.rb

@@ -7,45 +7,36 @@ require "fileutils"
 
 # Provides String#pluralize
 require "active_support/core_ext/string"
+# Provides Object#to_json
+require "active_support/core_ext/object/json"
 
 module Packwerk
   extend ActiveSupport::Autoload
 
-  autoload :ApplicationLoadPaths
-  autoload :ApplicationValidator
-  autoload :AssociationInspector
-  autoload :OffenseCollection
-  autoload :Cache
+  # Public APIs
+  autoload :Checker
   autoload :Cli
   autoload :Configuration
-  autoload :ConstantDiscovery
-  autoload :ConstantNameInspector
-  autoload :ConstNodeInspector
-  autoload :PackageTodo
-  autoload :FileProcessor
-  autoload :FilesForProcessing
-  autoload :Graph
+  autoload :ConstantContext
   autoload :Node
-  autoload :NodeHelpers
-  autoload :NodeProcessor
-  autoload :NodeProcessorFactory
-  autoload :NodeVisitor
   autoload :Offense
+  autoload :OffenseCollection
   autoload :OffensesFormatter
   autoload :OutputStyle
   autoload :Package
   autoload :PackageSet
-  autoload :ParsedConstantDefinitions
+  autoload :PackageTodo
   autoload :Parsers
-  autoload :ParseRun
-  autoload :UnresolvedReference
+  autoload :RailsLoadPaths
   autoload :Reference
-  autoload :ReferenceExtractor
   autoload :ReferenceOffense
-  autoload :Result
-  autoload :RunContext
-  autoload :Version
-  autoload :ViolationType
+  autoload :Validator
+
+  class Cli
+    extend ActiveSupport::Autoload
+
+    autoload :Result
+  end
 
   module OutputStyles
     extend ActiveSupport::Autoload
@@ -61,10 +52,37 @@ module Packwerk
   module Formatters
     extend ActiveSupport::Autoload
 
-    autoload :OffensesFormatter
     autoload :ProgressFormatter
   end
 
+  module Validator
+    extend ActiveSupport::Autoload
+
+    autoload :Result
+  end
+
+  # Private APIs
+  # Please submit an issue if you have a use-case for these
+  autoload :ApplicationValidator
+  autoload :AssociationInspector
+  autoload :Cache
+  autoload :ConstantDiscovery
+  autoload :ConstantNameInspector
+  autoload :ConstNodeInspector
+  autoload :ExtensionLoader
+  autoload :FileProcessor
+  autoload :FilesForProcessing
+  autoload :Graph
+  autoload :NodeHelpers
+  autoload :NodeProcessor
+  autoload :NodeProcessorFactory
+  autoload :NodeVisitor
+  autoload :ParsedConstantDefinitions
+  autoload :ParseRun
+  autoload :ReferenceExtractor
+  autoload :RunContext
+  autoload :UnresolvedReference
+
   module Generators
     extend ActiveSupport::Autoload
 
@@ -72,6 +90,8 @@ module Packwerk
     autoload :RootPackage
   end
 
+  private_constant :Generators
+
   module ReferenceChecking
     extend ActiveSupport::Autoload
 
@@ -80,9 +100,27 @@ module Packwerk
     module Checkers
       extend ActiveSupport::Autoload
 
-      autoload :Checker
       autoload :DependencyChecker
       autoload :PrivacyChecker
     end
   end
+
+  private_constant :ReferenceChecking
+
+  class ApplicationValidator
+    extend ActiveSupport::Autoload
+
+    autoload :Helpers
+  end
 end
+
+require "packwerk/version"
+
+# Required to register the DefaultOffensesFormatter
+# We put this at the *end* of the file to specify all autoloads first
+require "packwerk/formatters/default_offenses_formatter"
+
+# Required to register the default DependencyChecker
+require "packwerk/reference_checking/checkers/dependency_checker"
+# Required to register the default DependencyValidator
+require "packwerk/validators/dependency_validator"

data/packwerk.gemspec

@@ -38,9 +38,9 @@ Gem::Specification.new do |spec|
   end
   spec.require_paths = ["lib"]
 
-  spec.required_ruby_version = ">= 2.6"
+  spec.required_ruby_version = ">= 2.7"
 
-  spec.add_dependency("activesupport", ">= 5.2")
+  spec.add_dependency("activesupport", ">= 6.0")
   spec.add_dependency("bundler")
   spec.add_dependency("constant_resolver", ">= 0.2.0")
   spec.add_dependency("parallel")
@@ -53,4 +53,6 @@ Gem::Specification.new do |spec|
 
   # For ERB parsing
   spec.add_dependency("better_html")
+
+  spec.add_development_dependency("railties")
 end