packwerk 1.0.0 → 1.1.2

data/lib/packwerk/output_style.rb

@@ -0,0 +1,20 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Packwerk
+  module OutputStyle
+    extend T::Sig
+    extend T::Helpers
+
+    interface!
+
+    sig { abstract.returns(String) }
+    def reset; end
+
+    sig { abstract.returns(String) }
+    def filename; end
+
+    sig { abstract.returns(String) }
+    def error; end
+  end
+end

data/lib/packwerk/output_styles/coloured.rb

@@ -0,0 +1,29 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Packwerk
+  module OutputStyles
+    # See https://en.wikipedia.org/wiki/ANSI_escape_code#3/4_bit for ANSI escape colour codes
+    class Coloured
+      extend T::Sig
+      include OutputStyle
+
+      sig { override.returns(String) }
+      def reset
+        "\033[m"
+      end
+
+      sig { override.returns(String) }
+      def filename
+        # 36 is foreground cyan
+        "\033[36m"
+      end
+
+      sig { override.returns(String) }
+      def error
+        # 31 is foreground red
+        "\033[31m"
+      end
+    end
+  end
+end

data/lib/packwerk/output_styles/plain.rb

@@ -0,0 +1,26 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Packwerk
+  module OutputStyles
+    class Plain
+      extend T::Sig
+      include OutputStyle
+
+      sig { override.returns(String) }
+      def reset
+        ""
+      end
+
+      sig { override.returns(String) }
+      def filename
+        ""
+      end
+
+      sig { override.returns(String) }
+      def error
+        ""
+      end
+    end
+  end
+end

data/lib/packwerk/package.rb

@@ -33,13 +33,20 @@ module Packwerk
     end
 
     def public_path
-      @public_path ||= File.join(@name, "app/public/")
+      @public_path ||= File.join(@name, user_defined_public_path || "app/public/")
     end
 
     def public_path?(path)
       path.start_with?(public_path)
     end
 
+    def user_defined_public_path
+      return unless @config["public_path"]
+      return @config["public_path"] if @config["public_path"].end_with?("/")
+
+      @config["public_path"] + "/"
+    end
+
     def <=>(other)
       return nil unless other.is_a?(self.class)
       name <=> other.name

data/lib/packwerk/package_set.rb

@@ -25,13 +25,20 @@ module Packwerk
         new(packages)
       end
 
-      private
-
       def package_paths(root_path, package_pathspec)
-        Dir.glob(File.join(root_path, package_pathspec, PACKAGE_CONFIG_FILENAME))
-          .map! { |path| Pathname.new(path) }
+        bundle_path_match = Bundler.bundle_path.join("**").to_s
+
+        glob_patterns = Array(package_pathspec).map do |pathspec|
+          File.join(root_path, pathspec, PACKAGE_CONFIG_FILENAME)
+        end
+
+        Dir.glob(glob_patterns)
+          .map { |path| Pathname.new(path).cleanpath }
+          .reject { |path| path.realpath.fnmatch(bundle_path_match) }
       end
 
+      private
+
       def create_root_package_if_none_in(packages)
         return if packages.any?(&:root?)
         packages << Package.new(name: Package::ROOT_PACKAGE_NAME, config: nil)
@@ -53,7 +60,8 @@ module Packwerk
     end
 
     def package_from_path(file_path)
-      @packages.values.find { |package| package.package_path?(file_path) }
+      path_string = file_path.to_s
+      @packages.values.find { |package| package.package_path?(path_string) }
     end
   end
 end

data/lib/packwerk/parsed_constant_definitions.rb

@@ -28,8 +28,8 @@ module Packwerk
 
       fully_qualified_constant_name = "::#{constant_name}"
 
-      possible_namespaces = namespace_path.reduce([""]) do |acc, current|
-        acc << acc.last + "::" + current
+      possible_namespaces = namespace_path.each_with_object([""]) do |current, acc|
+        acc << "#{acc.last}::#{current}" if acc.last && current
       end
 
       possible_namespaces.map { |namespace| namespace + fully_qualified_constant_name }
@@ -38,12 +38,12 @@ module Packwerk
     private
 
     def collect_local_definitions_from_root(node, current_namespace_path = [])
-      if Node.type(node) == Node::CONSTANT_ASSIGNMENT
+      if Node.constant_assignment?(node)
         add_definition(Node.constant_name(node), current_namespace_path, Node.name_location(node))
       elsif Node.module_name_from_definition(node)
         # handle compact constant nesting (e.g. "module Sales::Order")
         tempnode = node
-        while (tempnode = Node.each_child(tempnode).find { |n| Node.type(n) == Node::CONSTANT })
+        while (tempnode = Node.each_child(tempnode).find { |n| Node.constant?(n) })
           add_definition(Node.constant_name(tempnode), current_namespace_path, Node.name_location(tempnode))
         end
 

data/lib/packwerk/parsers/erb.rb

@@ -19,6 +19,10 @@ module Packwerk
       def call(io:, file_path: "<unknown>")
         buffer = Parser::Source::Buffer.new(file_path)
         buffer.source = io.read
+        parse_buffer(buffer, file_path: file_path)
+      end
+
+      def parse_buffer(buffer, file_path:)
         parser = @parser_class.new(buffer, template_language: :html)
         to_ruby_ast(parser.ast, file_path)
       rescue EncodingError => e

data/lib/packwerk/parsers/factory.rb

@@ -26,9 +26,18 @@ module Packwerk
         when RUBY_REGEX
           @ruby_parser ||= Ruby.new
         when ERB_REGEX
-          @erb_parser ||= Erb.new
+          @erb_parser ||= erb_parser_class.new
         end
       end
+
+      def erb_parser_class
+        @erb_parser_class ||= Erb
+      end
+
+      def erb_parser_class=(klass)
+        @erb_parser_class = klass
+        @erb_parser = nil
+      end
     end
   end
 end

data/lib/packwerk/privacy_checker.rb

@@ -1,28 +1,39 @@
-# typed: true
+# typed: strict
 # frozen_string_literal: true
 
 require "packwerk/violation_type"
+require "packwerk/checker"
 
 module Packwerk
   class PrivacyChecker
+    extend T::Sig
+    include Checker
+
+    sig { override.returns(Packwerk::ViolationType) }
     def violation_type
       ViolationType::Privacy
     end
 
+    sig do
+      override
+        .params(reference: Packwerk::Reference, reference_lister: Packwerk::ReferenceLister)
+        .returns(T::Boolean)
+    end
     def invalid_reference?(reference, reference_lister)
-      return if reference.constant.public?
+      return false if reference.constant.public?
 
       privacy_option = reference.constant.package.enforce_privacy
-      return if enforcement_disabled?(privacy_option)
+      return false if enforcement_disabled?(privacy_option)
 
-      return unless privacy_option == true ||
+      return false unless privacy_option == true ||
         explicitly_private_constant?(reference.constant, explicitly_private_constants: privacy_option)
 
-      return if reference_lister.listed?(reference, violation_type: violation_type)
+      return false if reference_lister.listed?(reference, violation_type: violation_type)
 
       true
     end
 
+    sig { override.params(reference: Packwerk::Reference).returns(String) }
     def message_for(reference)
       source_desc = reference.source_package ? "'#{reference.source_package}'" : "here"
       "Privacy violation: '#{reference.constant.name}' is private to '#{reference.constant.package}' but " \
@@ -32,12 +43,22 @@ module Packwerk
 
     private
 
+    sig do
+      params(
+        constant: ConstantDiscovery::ConstantContext,
+        explicitly_private_constants: T::Array[String]
+      ).returns(T::Boolean)
+    end
     def explicitly_private_constant?(constant, explicitly_private_constants:)
       explicitly_private_constants.include?(constant.name) ||
         # nested constants
         explicitly_private_constants.any? { |epc| constant.name.start_with?(epc + "::") }
     end
 
+    sig do
+      params(privacy_option: T.nilable(T.any(T::Boolean, T::Array[String])))
+        .returns(T::Boolean)
+    end
     def enforcement_disabled?(privacy_option)
       [false, nil].include?(privacy_option)
     end

data/lib/packwerk/run_context.rb

@@ -1,47 +1,49 @@
 # typed: true
 # frozen_string_literal: true
 
-require "active_support/inflector"
 require "constant_resolver"
 
 require "packwerk/association_inspector"
-require "packwerk/checking_deprecated_references"
 require "packwerk/constant_discovery"
 require "packwerk/const_node_inspector"
 require "packwerk/dependency_checker"
 require "packwerk/file_processor"
-require "packwerk/node_processor"
+require "packwerk/inflector"
 require "packwerk/package_set"
 require "packwerk/privacy_checker"
 require "packwerk/reference_extractor"
+require "packwerk/node_processor_factory"
 
 module Packwerk
   class RunContext
+    extend T::Sig
+
     attr_reader(
-      :checkers,
-      :constant_name_inspectors,
-      :context_provider,
       :root_path,
-      :file_processor,
-      :node_processor_class,
-      :reference_lister
+      :load_paths,
+      :package_paths,
+      :inflector,
+      :custom_associations,
+      :checker_classes,
     )
 
+    attr_accessor :reference_lister
+
     DEFAULT_CHECKERS = [
       ::Packwerk::DependencyChecker,
       ::Packwerk::PrivacyChecker,
     ]
 
     class << self
-      def from_configuration(configuration, reference_lister: nil)
-        default_reference_lister = reference_lister ||
-          ::Packwerk::CheckingDeprecatedReferences.new(configuration.root_path)
+      def from_configuration(configuration, reference_lister:)
+        inflector = ::Packwerk::Inflector.from_file(configuration.inflections_file)
         new(
           root_path: configuration.root_path,
           load_paths: configuration.load_paths,
-          inflector: ActiveSupport::Inflector,
+          package_paths: configuration.package_paths,
+          inflector: inflector,
           custom_associations: configuration.custom_associations,
-          reference_lister: default_reference_lister,
+          reference_lister: reference_lister,
         )
       end
     end
@@ -53,51 +55,73 @@ module Packwerk
       inflector: nil,
       custom_associations: [],
       checker_classes: DEFAULT_CHECKERS,
-      node_processor_class: NodeProcessor,
-      reference_lister: nil
+      reference_lister:
     )
-      @root_path = File.expand_path(root_path)
+      @root_path = root_path
+      @load_paths = load_paths
+      @package_paths = package_paths
+      @inflector = inflector
+      @custom_associations = custom_associations
+      @checker_classes = checker_classes
+      @reference_lister = reference_lister
+    end
 
-      resolver = ConstantResolver.new(
-        root_path: @root_path,
-        load_paths: load_paths,
-        inflector: inflector,
-      )
+    sig { params(file: String).returns(T::Array[T.nilable(::Packwerk::Offense)]) }
+    def process_file(file:)
+      file_processor.call(file)
+    end
+
+    private
+
+    sig { returns(FileProcessor) }
+    def file_processor
+      @file_processor ||= FileProcessor.new(node_processor_factory: node_processor_factory)
+    end
 
-      package_set = ::Packwerk::PackageSet.load_all_from(@root_path, package_pathspec: package_paths)
+    sig { returns(NodeProcessorFactory) }
+    def node_processor_factory
+      NodeProcessorFactory.new(
+        context_provider: context_provider,
+        checkers: checkers,
+        root_path: root_path,
+        constant_name_inspectors: constant_name_inspectors,
+        reference_lister: reference_lister
+      )
+    end
 
-      @context_provider = ::Packwerk::ConstantDiscovery.new(
+    sig { returns(ConstantDiscovery) }
+    def context_provider
+      ::Packwerk::ConstantDiscovery.new(
         constant_resolver: resolver,
         packages: package_set
       )
+    end
 
-      @reference_lister = reference_lister || ::Packwerk::CheckingDeprecatedReferences.new(@root_path)
+    sig { returns(ConstantResolver) }
+    def resolver
+      ConstantResolver.new(
+        root_path: root_path,
+        load_paths: load_paths,
+        inflector: inflector,
+      )
+    end
 
-      @checkers = checker_classes.map(&:new)
+    sig { returns(PackageSet) }
+    def package_set
+      ::Packwerk::PackageSet.load_all_from(root_path, package_pathspec: package_paths)
+    end
 
-      @constant_name_inspectors = [
+    sig { returns(T::Array[Checker]) }
+    def checkers
+      checker_classes.map(&:new)
+    end
+
+    sig { returns(T::Array[ConstantNameInspector]) }
+    def constant_name_inspectors
+      [
         ::Packwerk::ConstNodeInspector.new,
         ::Packwerk::AssociationInspector.new(inflector: inflector, custom_associations: custom_associations),
       ]
-
-      @node_processor_class = node_processor_class
-      @file_processor = FileProcessor.new(run_context: self)
-    end
-
-    def node_processor_for(filename:, ast_node:)
-      reference_extractor = ::Packwerk::ReferenceExtractor.new(
-        context_provider: context_provider,
-        constant_name_inspectors: constant_name_inspectors,
-        root_node: ast_node,
-        root_path: root_path,
-      )
-
-      node_processor_class.new(
-        reference_extractor: reference_extractor,
-        reference_lister: @reference_lister,
-        filename: filename,
-        checkers: checkers,
-      )
     end
   end
 end

data/lib/packwerk/sanity_checker.rb

@@ -1,4 +1,4 @@
-# typed: ignore
+# typed: false
 # frozen_string_literal: true
 
 require "packwerk/application_validator"

data/lib/packwerk/spring_command.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
-# typed: ignore
+# typed: false
 
 require "spring/commands"
 

data/lib/packwerk/updating_deprecated_references.rb

@@ -1,51 +1,14 @@
 # typed: true
 # frozen_string_literal: true
 
-require "sorbet-runtime"
-
-require "packwerk/deprecated_references"
-require "packwerk/reference"
-require "packwerk/reference_lister"
-require "packwerk/violation_type"
+require "packwerk/cache_deprecated_references"
 
 module Packwerk
-  class UpdatingDeprecatedReferences
-    extend T::Sig
-    include ReferenceLister
-
-    def initialize(root_path, deprecated_references = {})
-      @root_path = root_path
-      @deprecated_references = deprecated_references
-    end
-
-    sig do
-      params(reference: Packwerk::Reference, violation_type: ViolationType)
-        .returns(T::Boolean)
-        .override
-    end
-    def listed?(reference, violation_type:)
-      deprecated_references = deprecated_references_for(reference.source_package)
-      deprecated_references.add_entries(reference, violation_type.serialize)
-      true
-    end
-
+  class UpdatingDeprecatedReferences < CacheDeprecatedReferences
     def dump_deprecated_references_files
       @deprecated_references.each do |_, deprecated_references_file|
         deprecated_references_file.dump
       end
     end
-
-    private
-
-    def deprecated_references_for(package)
-      @deprecated_references[package] ||= Packwerk::DeprecatedReferences.new(
-        package,
-        deprecated_references_file_for(package),
-      )
-    end
-
-    def deprecated_references_file_for(package)
-      File.join(@root_path, package.name, "deprecated_references.yml")
-    end
   end
 end