packwerk 1.0.0

data/lib/packwerk/dependency_checker.rb

@@ -0,0 +1,28 @@
+# typed: true
+# frozen_string_literal: true
+
+require "packwerk/violation_type"
+
+module Packwerk
+  class DependencyChecker
+    def violation_type
+      ViolationType::Dependency
+    end
+
+    def invalid_reference?(reference, reference_lister)
+      return unless reference.source_package
+      return unless reference.source_package.enforce_dependencies?
+      return if reference.source_package.dependency?(reference.constant.package)
+      return if reference_lister.listed?(reference, violation_type: violation_type)
+      true
+    end
+
+    def message_for(reference)
+      "Dependency violation: #{reference.constant.name} belongs to '#{reference.constant.package}', but " \
+        "'#{reference.source_package}' does not specify a dependency on " \
+        "'#{reference.constant.package}'.\n" \
+        "Are we missing an abstraction?\n" \
+        "Is the code making the reference, and the referenced constant, in the right packages?\n"
+    end
+  end
+end

data/lib/packwerk/deprecated_references.rb

@@ -0,0 +1,92 @@
+# typed: true
+# frozen_string_literal: true
+
+require "sorbet-runtime"
+require "yaml"
+
+require "packwerk/reference"
+require "packwerk/reference_lister"
+require "packwerk/violation_type"
+
+module Packwerk
+  class DeprecatedReferences
+    extend T::Sig
+    include ReferenceLister
+
+    def initialize(package, filepath)
+      @package = package
+      @filepath = filepath
+      @new_entries = {}
+    end
+
+    sig do
+      params(reference: Packwerk::Reference, violation_type: ViolationType)
+        .returns(T::Boolean)
+        .override
+    end
+    def listed?(reference, violation_type:)
+      violated_constants_found = deprecated_references.dig(reference.constant.package.name, reference.constant.name)
+      return false unless violated_constants_found
+
+      violated_constant_in_file = violated_constants_found.fetch("files", []).include?(reference.relative_path)
+      return false unless violated_constant_in_file
+
+      violated_constants_found.fetch("violations", []).include?(violation_type.serialize)
+    end
+
+    def add_entries(reference, violation_type)
+      package_violations = @new_entries.fetch(reference.constant.package.name, {})
+      entries_for_file = package_violations[reference.constant.name] ||= {}
+
+      entries_for_file["violations"] ||= []
+      entries_for_file["violations"] << violation_type
+
+      entries_for_file["files"] ||= []
+      entries_for_file["files"] << reference.relative_path.to_s
+
+      @new_entries[reference.constant.package.name] = package_violations
+    end
+
+    def dump
+      if @new_entries.empty?
+        File.delete(@filepath) if File.exist?(@filepath)
+      else
+        prepare_entries_for_dump
+        message = <<~MESSAGE
+          # This file contains a list of dependencies that are not part of the long term plan for #{@package.name}.
+          # We should generally work to reduce this list, but not at the expense of actually getting work done.
+          #
+          # You can regenerate this file using the following command:
+          #
+          # bundle exec packwerk update #{@package.name}
+        MESSAGE
+        File.open(@filepath, "w") do |f|
+          f.write(message)
+          f.write(@new_entries.to_yaml)
+        end
+      end
+    end
+
+    private
+
+    def prepare_entries_for_dump
+      @new_entries.each do |package_name, package_violations|
+        package_violations.each do |_, entries_for_file|
+          entries_for_file["violations"].sort!.uniq!
+          entries_for_file["files"].sort!.uniq!
+        end
+        @new_entries[package_name] = package_violations.sort.to_h
+      end
+
+      @new_entries = @new_entries.sort.to_h
+    end
+
+    def deprecated_references
+      @deprecated_references ||= if File.exist?(@filepath)
+        YAML.load_file(@filepath) || {}
+      else
+        {}
+      end
+    end
+  end
+end

data/lib/packwerk/file_processor.rb

@@ -0,0 +1,43 @@
+# typed: false
+# frozen_string_literal: true
+
+require "ast/node"
+
+require "packwerk/node"
+require "packwerk/offense"
+require "packwerk/parsers"
+
+module Packwerk
+  class FileProcessor
+    class UnknownFileTypeResult < Offense
+      def initialize(file:)
+        super(file: file, message: "unknown file type")
+      end
+    end
+
+    def initialize(run_context:, parser_factory: nil)
+      @run_context = run_context
+      @parser_factory = parser_factory || Packwerk::Parsers::Factory.instance
+    end
+
+    def call(file_path)
+      parser = @parser_factory.for_path(file_path)
+      return [UnknownFileTypeResult.new(file: file_path)] if parser.nil?
+
+      node = File.open(file_path, "r", external_encoding: Encoding::UTF_8) do |file|
+        parser.call(io: file, file_path: file_path)
+      rescue Parsers::ParseError => e
+        return [e.result]
+      end
+
+      result = []
+      if node
+        @node_processor = @run_context.node_processor_for(filename: file_path, ast_node: node)
+        node_visitor = Packwerk::NodeVisitor.new(node_processor: @node_processor)
+
+        node_visitor.visit(node, ancestors: [], result: result)
+      end
+      result
+    end
+  end
+end

data/lib/packwerk/files_for_processing.rb

@@ -0,0 +1,67 @@
+# typed: true
+# frozen_string_literal: true
+
+module Packwerk
+  class FilesForProcessing
+    class << self
+      def fetch(paths:, configuration:)
+        new(paths, configuration).files
+      end
+    end
+
+    def initialize(paths, configuration)
+      @paths = paths
+      @configuration = configuration
+    end
+
+    def files
+      include_files = if custom_files.empty?
+        configured_included_files
+      else
+        custom_files
+      end
+
+      include_files - configured_excluded_files
+    end
+
+    private
+
+    def custom_files
+      @custom_files ||= @paths.flat_map do |path|
+        path = File.expand_path(path, @configuration.root_path)
+        if File.file?(path)
+          path
+        else
+          custom_included_files(path)
+        end
+      end
+    end
+
+    def custom_included_files(path)
+      # Note, assuming include globs are always relative paths
+      absolute_includes = @configuration.include.map do |glob|
+        File.expand_path(glob, @configuration.root_path)
+      end
+
+      Dir.glob([File.join(path, "**", "*")]).select do |file_path|
+        absolute_includes.any? do |pattern|
+          File.fnmatch?(pattern, file_path, File::FNM_EXTGLOB)
+        end
+      end
+    end
+
+    def configured_included_files
+      files_for_globs(@configuration.include)
+    end
+
+    def configured_excluded_files
+      files_for_globs(@configuration.exclude)
+    end
+
+    def files_for_globs(globs)
+      globs
+        .flat_map { |glob| Dir[File.expand_path(glob, @configuration.root_path)] }
+        .uniq
+    end
+  end
+end

data/lib/packwerk/formatters/progress_formatter.rb

@@ -0,0 +1,46 @@
+# typed: true
+# frozen_string_literal: true
+
+require "benchmark"
+
+require "packwerk/inflector"
+require "packwerk/output_styles"
+
+module Packwerk
+  module Formatters
+    class ProgressFormatter
+      def initialize(out, style: OutputStyles::Plain)
+        @out = out
+        @style = style
+      end
+
+      def started(target_files)
+        files_size = target_files.size
+        files_string = Inflector.default.pluralize("file", files_size)
+        @out.puts("📦 Packwerk is inspecting #{files_size} #{files_string}")
+      end
+
+      def started_validation
+        @out.puts("📦 Packwerk is running validation...")
+
+        execution_time = Benchmark.realtime { yield }
+        finished(execution_time)
+
+        @out.puts("✅ Packages are valid. Use `packwerk check` to run static checks.")
+      end
+
+      def mark_as_inspected
+        @out.print(".")
+      end
+
+      def mark_as_failed
+        @out.print("#{@style.error}E#{@style.reset}")
+      end
+
+      def finished(execution_time)
+        @out.puts
+        @out.puts("📦 Finished in #{execution_time.round(2)} seconds")
+      end
+    end
+  end
+end

data/lib/packwerk/generators/application_validation.rb

@@ -0,0 +1,62 @@
+# typed: true
+# frozen_string_literal: true
+
+module Packwerk
+  module Generators
+    class ApplicationValidation
+      class << self
+        def generate(for_rails_app: false, root: ".", out: $stdout)
+          new(root, out: out).generate(for_rails_app: for_rails_app)
+        end
+      end
+
+      def initialize(root, out: $stdout)
+        @root = root
+        @out = out
+      end
+
+      def generate(for_rails_app:)
+        @out.puts("📦 Generating application validator...")
+        if for_rails_app
+          generate_packwerk_validate_script
+        else
+          generate_validation_test
+        end
+      end
+
+      private
+
+      def generate_packwerk_validate_script
+        destination_file_path = File.join(@root, "bin")
+        FileUtils.mkdir_p(destination_file_path)
+
+        if File.exist?(File.join(destination_file_path, "packwerk"))
+          @out.puts("⚠️  Packwerk application validation bin script already exists.")
+          return true
+        end
+
+        source_file_path = File.expand_path("../templates/packwerk", __FILE__)
+        FileUtils.cp(source_file_path, destination_file_path)
+
+        @out.puts("✅ Packwerk application validation bin script generated in #{destination_file_path}")
+        true
+      end
+
+      def generate_validation_test
+        destination_file_path = File.join(@root, "test")
+        FileUtils.mkdir_p(destination_file_path)
+
+        if File.exist?(File.join(destination_file_path, "packwerk_validator_test.rb"))
+          @out.puts("⚠️  Packwerk application validation test already exists.")
+          return true
+        end
+
+        source_file_path = File.expand_path("../templates/packwerk_validator_test.rb", __FILE__)
+        FileUtils.cp(source_file_path, destination_file_path)
+
+        @out.puts("✅ Packwerk application validation test generated in #{destination_file_path}")
+        true
+      end
+    end
+  end
+end

data/lib/packwerk/generators/configuration_file.rb

@@ -0,0 +1,69 @@
+# typed: true
+# frozen_string_literal: true
+
+require "packwerk/configuration"
+require "erb"
+
+module Packwerk
+  module Generators
+    class ConfigurationFile
+      extend T::Sig
+
+      CONFIGURATION_TEMPLATE_FILE_PATH = "templates/packwerk.yml.erb"
+
+      class << self
+        def generate(load_paths:, root:, out:)
+          new(load_paths: load_paths, root: root, out: out).generate
+        end
+      end
+
+      sig { params(load_paths: T::Array[String], root: String, out: T.any(StringIO, IO)).void }
+      def initialize(load_paths:, root:, out: $stdout)
+        @load_paths = load_paths
+        @root = root
+        @out = out
+
+        set_template_variables
+      end
+
+      sig { returns(T::Boolean) }
+      def generate
+        @out.puts("📦 Generating Packwerk configuration file...")
+        default_config_path = File.join(@root, ::Packwerk::Configuration::DEFAULT_CONFIG_PATH)
+
+        if File.exist?(default_config_path)
+          @out.puts("⚠️  Packwerk configuration file already exists.")
+          return true
+        end
+
+        File.write(default_config_path, render)
+
+        @out.puts("✅ Packwerk configuration file generated in #{default_config_path}")
+        true
+      end
+
+      private
+
+      def set_template_variables
+        @load_paths_formatted = if @load_paths.empty?
+          "# load_paths:\n# - 'app/models'\n"
+        else
+          @load_paths.map { |path| "- #{path}\n" }.join
+        end
+
+        @load_paths_comment = unless @load_paths.empty?
+          "# These load paths were auto generated by Packwerk.\nload_paths:\n"
+        end
+      end
+
+      def render
+        ERB.new(template, trim_mode: "-").result(binding)
+      end
+
+      def template
+        template_file_path = File.join(__dir__, CONFIGURATION_TEMPLATE_FILE_PATH)
+        File.read(template_file_path)
+      end
+    end
+  end
+end

data/lib/packwerk/generators/inflections_file.rb

@@ -0,0 +1,43 @@
+# typed: true
+# frozen_string_literal: true
+
+module Packwerk
+  module Generators
+    class InflectionsFile
+      extend T::Sig
+
+      class << self
+        def generate(root:, out:)
+          new(root, out: out).generate
+        end
+      end
+
+      def initialize(root, out: $stdout)
+        @root = root
+        @out = out
+      end
+
+      sig { returns(T::Boolean) }
+      def generate
+        ruby_inflection_file_exist = Dir.glob("#{@root}/**/inflections.rb").any?
+        yaml_inflection_file_exist = Dir.glob("#{@root}/**/inflections.yml").any?
+
+        if !ruby_inflection_file_exist || yaml_inflection_file_exist
+          return true
+        end
+
+        @out.puts("📦 Generating `inflections.yml` file...")
+
+        destination_file_path = File.join(@root, "config")
+        FileUtils.mkdir_p(destination_file_path)
+
+        source_file_path = File.join(__dir__, "/templates/inflections.yml")
+        FileUtils.cp(source_file_path, destination_file_path)
+
+        @out.puts("✅ `inflections.yml` generated in #{destination_file_path}")
+
+        true
+      end
+    end
+  end
+end