packwerk 1.0.0

data/lib/packwerk/generators/root_package.rb

@@ -0,0 +1,37 @@
+# typed: true
+# frozen_string_literal: true
+
+module Packwerk
+  module Generators
+    class RootPackage
+      extend T::Sig
+
+      class << self
+        def generate(root:, out:)
+          new(root: root, out: out).generate
+        end
+      end
+
+      def initialize(root:, out: $stdout)
+        @root = root
+        @out = out
+      end
+
+      sig { returns(T::Boolean) }
+      def generate
+        if Dir.glob("#{@root}/package.yml").any?
+          @out.puts("⚠️  Root package already exists.")
+          return true
+        end
+
+        @out.puts("📦 Generating `package.yml` file for root package...")
+
+        source_file_path = File.join(__dir__, "/templates/package.yml")
+        FileUtils.cp(source_file_path, @root)
+
+        @out.puts("✅ `package.yml` for the root package generated in #{@root}")
+        true
+      end
+    end
+  end
+end

data/lib/packwerk/generators/templates/inflections.yml

@@ -0,0 +1,6 @@
+# List your inflections in this file instead of `inflections.rb`
+# See steps to set up custom inflections:
+# https://github.com/Shopify/packwerk/blob/main/USAGE.md#Inflections
+
+# acronym:
+#   - "GraphQL"

data/lib/packwerk/generators/templates/package.yml

@@ -0,0 +1,17 @@
+# This file represents the root package of the application
+# Please validate the configuration using `bin/packwerk validate` (for Rails applications) or running the auto generated
+# test case (for non-Rails projects). You can then use `packwerk check` to check your code.
+
+# Turn on dependency checks for this package
+enforce_dependencies: true
+
+# Turn on privacy checks for this package
+# enforcing privacy is often not useful for the root package, because it would require defining a public interface
+# for something that should only be a thin wrapper in the first place.
+# We recommend enabling this for any new packages you create to aid with encapsulation.
+enforce_privacy: false
+
+# A list of this package's dependencies
+# Note that packages in this list require their own `package.yml` file
+# dependencies:
+# - "packages/billing"

data/lib/packwerk/generators/templates/packwerk

@@ -0,0 +1,23 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# This file was auto-generated by Packwerk through `packwerk init`
+
+# Needs to be run in test environment in order to have test helper paths available in the autoload paths
+ENV["RAILS_ENV"] = "test"
+
+# Command line arguments needs to be duplicated because spring modifies it
+packwerk_argv = ARGV.dup
+
+begin
+  load(File.expand_path("../spring", __FILE__))
+rescue LoadError => e
+  raise unless e.message.include?("spring")
+end
+
+require File.expand_path("../../config/environment", __FILE__)
+
+require "packwerk"
+
+cli = Packwerk::Cli.new
+cli.run(packwerk_argv)

data/lib/packwerk/generators/templates/packwerk.yml.erb

@@ -0,0 +1,23 @@
+# See: Setting up the configuration file
+# https://github.com/Shopify/packwerk/blob/main/USAGE.md#setting-up-the-configuration-file
+
+# List of patterns for folder paths to include
+# include:
+# - "**/*.{rb,rake,erb}"
+
+# List of patterns for folder paths to exclude
+# exclude:
+# - "{bin,node_modules,script,tmp}/**/*"
+
+# Patterns to find package configuration files
+# package_paths: "**/"
+
+# List of application load paths
+<%= @load_paths_comment -%>
+<%= @load_paths_formatted %>
+# List of custom associations, if any
+# custom_associations:
+# - "cache_belongs_to"
+
+# Location of inflections file
+# inflections_file: "config/inflections.yml"

data/lib/packwerk/generators/templates/packwerk_validator_test.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require "test_helper"
+require "packwerk"
+
+# This test is necessary to make sure that the package system is working correctly
+class PackwerkValidatorTest < Minitest::Test
+  def test_the_application_is_correctly_set_up_for_the_package_system
+    assert(Packwerk::Cli.new.execute_command(["validate"]))
+  end
+end

data/lib/packwerk/graph.rb

@@ -0,0 +1,74 @@
+# typed: true
+# frozen_string_literal: true
+
+module Packwerk
+  class Graph
+    def initialize(*edges)
+      @edges = edges.uniq
+      @cycles = Set.new
+      process
+    end
+
+    def cycles
+      @cycles.dup
+    end
+
+    def acyclic?
+      @cycles.empty?
+    end
+
+    private
+
+    def nodes
+      @edges.flatten.uniq
+    end
+
+    def process
+      # See https://en.wikipedia.org/wiki/Topological_sorting#Depth-first_search
+      @processed ||= begin
+        nodes.each { |node| visit(node) }
+        true
+      end
+    end
+
+    def visit(node, visited_nodes: Set.new, path: [])
+      # Already visited, short circuit to avoid unnecessary processing
+      return if visited_nodes.include?(node)
+
+      # We've returned to a node that we've already visited, so we've found a cycle!
+      if path.include?(node)
+        # Filter out the part of the path that isn't a cycle. For example, with the following path:
+        #
+        #   a -> b -> c -> d -> b
+        #
+        # "a" isn't part of the cycle. The cycle should only appear once in the path, so we reject
+        # everything from the beginning to the first instance of the current node.
+        add_cycle(path.drop_while { |n| n != node })
+        return
+      end
+
+      path << node
+      neighbours(node).each do |neighbour|
+        visit(neighbour, visited_nodes: visited_nodes, path: path)
+      end
+      path.pop
+    ensure
+      visited_nodes << node
+    end
+
+    def neighbours(node)
+      @edges
+        .lazy
+        .select { |src, _dst| src == node }
+        .map { |_src, dst| dst }
+    end
+
+    def add_cycle(cycle)
+      # Ensure that the lexicographically smallest item is the first one labeled in a cycle
+      min_node = cycle.min
+      cycle.rotate! until cycle.first == min_node
+
+      @cycles << cycle
+    end
+  end
+end

data/lib/packwerk/inflections/custom.rb

@@ -0,0 +1,33 @@
+# typed: true
+# frozen_string_literal: true
+
+require "yaml"
+
+module Packwerk
+  module Inflections
+    class Custom
+      SUPPORTED_INFLECTION_METHODS = %w(acronym human irregular plural singular uncountable)
+
+      attr_accessor :inflections
+
+      def initialize(custom_inflection_file = nil)
+        if custom_inflection_file && File.exist?(custom_inflection_file)
+          @inflections = YAML.load_file(custom_inflection_file) || {}
+
+          invalid_inflections = @inflections.keys - SUPPORTED_INFLECTION_METHODS
+          raise ArgumentError, "Unsupported inflection types: #{invalid_inflections}" if invalid_inflections.any?
+        else
+          @inflections = []
+        end
+      end
+
+      def apply_to(inflections_object)
+        @inflections.each do |inflection_type, inflections|
+          inflections.each do |inflection|
+            inflections_object.public_send(inflection_type, *Array(inflection))
+          end
+        end
+      end
+    end
+  end
+end

data/lib/packwerk/inflections/default.rb

@@ -0,0 +1,73 @@
+# typed: true
+# frozen_string_literal: true
+
+module Packwerk
+  module Inflections
+    module Default
+      class << self
+        def apply_to(inflections_object)
+          # copied from active_support/inflections
+          # https://github.com/rails/rails/blob/d2ae2c3103e93783971d5356d0b3fd1b4070d6cf/activesupport/lib/active_support/inflections.rb#L12
+          inflections_object.plural(/$/, "s")
+          inflections_object.plural(/s$/i, "s")
+          inflections_object.plural(/^(ax|test)is$/i, '\1es')
+          inflections_object.plural(/(octop|vir)us$/i, '\1i')
+          inflections_object.plural(/(octop|vir)i$/i, '\1i')
+          inflections_object.plural(/(alias|status)$/i, '\1es')
+          inflections_object.plural(/(bu)s$/i, '\1ses')
+          inflections_object.plural(/(buffal|tomat)o$/i, '\1oes')
+          inflections_object.plural(/([ti])um$/i, '\1a')
+          inflections_object.plural(/([ti])a$/i, '\1a')
+          inflections_object.plural(/sis$/i, "ses")
+          inflections_object.plural(/(?:([^f])fe|([lr])f)$/i, '\1\2ves')
+          inflections_object.plural(/(hive)$/i, '\1s')
+          inflections_object.plural(/([^aeiouy]|qu)y$/i, '\1ies')
+          inflections_object.plural(/(x|ch|ss|sh)$/i, '\1es')
+          inflections_object.plural(/(matr|vert|ind)(?:ix|ex)$/i, '\1ices')
+          inflections_object.plural(/^(m|l)ouse$/i, '\1ice')
+          inflections_object.plural(/^(m|l)ice$/i, '\1ice')
+          inflections_object.plural(/^(ox)$/i, '\1en')
+          inflections_object.plural(/^(oxen)$/i, '\1')
+          inflections_object.plural(/(quiz)$/i, '\1zes')
+
+          inflections_object.singular(/s$/i, "")
+          inflections_object.singular(/(ss)$/i, '\1')
+          inflections_object.singular(/(n)ews$/i, '\1ews')
+          inflections_object.singular(/([ti])a$/i, '\1um')
+          inflections_object.singular(/((a)naly|(b)a|(d)iagno|(p)arenthe|(p)rogno|(s)ynop|(t)he)(sis|ses)$/i, '\1sis')
+          inflections_object.singular(/(^analy)(sis|ses)$/i, '\1sis')
+          inflections_object.singular(/([^f])ves$/i, '\1fe')
+          inflections_object.singular(/(hive)s$/i, '\1')
+          inflections_object.singular(/(tive)s$/i, '\1')
+          inflections_object.singular(/([lr])ves$/i, '\1f')
+          inflections_object.singular(/([^aeiouy]|qu)ies$/i, '\1y')
+          inflections_object.singular(/(s)eries$/i, '\1eries')
+          inflections_object.singular(/(m)ovies$/i, '\1ovie')
+          inflections_object.singular(/(x|ch|ss|sh)es$/i, '\1')
+          inflections_object.singular(/^(m|l)ice$/i, '\1ouse')
+          inflections_object.singular(/(bus)(es)?$/i, '\1')
+          inflections_object.singular(/(o)es$/i, '\1')
+          inflections_object.singular(/(shoe)s$/i, '\1')
+          inflections_object.singular(/(cris|test)(is|es)$/i, '\1is')
+          inflections_object.singular(/^(a)x[ie]s$/i, '\1xis')
+          inflections_object.singular(/(octop|vir)(us|i)$/i, '\1us')
+          inflections_object.singular(/(alias|status)(es)?$/i, '\1')
+          inflections_object.singular(/^(ox)en/i, '\1')
+          inflections_object.singular(/(vert|ind)ices$/i, '\1ex')
+          inflections_object.singular(/(matr)ices$/i, '\1ix')
+          inflections_object.singular(/(quiz)zes$/i, '\1')
+          inflections_object.singular(/(database)s$/i, '\1')
+
+          inflections_object.irregular("person", "people")
+          inflections_object.irregular("man", "men")
+          inflections_object.irregular("child", "children")
+          inflections_object.irregular("sex", "sexes")
+          inflections_object.irregular("move", "moves")
+          inflections_object.irregular("zombie", "zombies")
+
+          inflections_object.uncountable(%w(equipment information rice money species series fish sheep jeans police))
+        end
+      end
+    end
+  end
+end

data/lib/packwerk/inflector.rb

@@ -0,0 +1,41 @@
+# typed: true
+# frozen_string_literal: true
+
+require "active_support/inflector"
+require "packwerk/inflections/default"
+require "packwerk/inflections/custom"
+
+module Packwerk
+  class Inflector
+    class << self
+      def default
+        @default ||= new
+      end
+    end
+
+    # For #camelize, #classify, #pluralize, #singularize
+    include ::ActiveSupport::Inflector
+
+    def initialize(custom_inflection_file: nil)
+      @inflections = ::ActiveSupport::Inflector::Inflections.new
+
+      Inflections::Default.apply_to(@inflections)
+
+      Inflections::Custom.new(custom_inflection_file).apply_to(@inflections)
+    end
+
+    def pluralize(word, count = nil)
+      if count == 1
+        singularize(word)
+      else
+        super(word)
+      end
+    end
+
+    private
+
+    def inflections(_ = nil)
+      @inflections
+    end
+  end
+end

data/lib/packwerk/node.rb

@@ -0,0 +1,259 @@
+# typed: true
+# frozen_string_literal: true
+
+require "parser/ast/node"
+
+module Packwerk
+  module Node
+    BLOCK = :block
+    CLASS = :class
+    CONSTANT = :const
+    CONSTANT_ASSIGNMENT = :casgn
+    CONSTANT_ROOT_NAMESPACE = :cbase
+    HASH = :hash
+    HASH_PAIR = :pair
+    METHOD_CALL = :send
+    MODULE = :module
+    STRING = :str
+    SYMBOL = :sym
+
+    class TypeError < ArgumentError; end
+    Location = Struct.new(:line, :column)
+
+    class << self
+      def class_or_module_name(class_or_module_node)
+        case type(class_or_module_node)
+        when CLASS, MODULE
+          # (class (const nil :Foo) (const nil :Bar) (nil))
+          #   "class Foo < Bar; end"
+          # (module (const nil :Foo) (nil))
+          #   "module Foo; end"
+          identifier = class_or_module_node.children[0]
+          constant_name(identifier)
+        else
+          raise TypeError
+        end
+      end
+
+      def constant_name(constant_node)
+        case type(constant_node)
+        when CONSTANT_ROOT_NAMESPACE
+          ""
+        when CONSTANT, CONSTANT_ASSIGNMENT
+          # (const nil :Foo)
+          #   "Foo"
+          # (const (cbase) :Foo)
+          #   "::Foo"
+          # (const (lvar :a) :Foo)
+          #   "a::Foo"
+          # (casgn nil :Foo (int 1))
+          #   "Foo = 1"
+          # (casgn (cbase) :Foo (int 1))
+          #   "::Foo = 1"
+          # (casgn (lvar :a) :Foo (int 1))
+          #   "a::Foo = 1"
+          namespace, name = constant_node.children
+          if namespace
+            [constant_name(namespace), name].join("::")
+          else
+            name.to_s
+          end
+        else
+          raise TypeError
+        end
+      end
+
+      def each_child(node)
+        if block_given?
+          node.children.each do |child|
+            yield child if child.is_a?(Parser::AST::Node)
+          end
+        else
+          enum_for(:each_child, node)
+        end
+      end
+
+      def enclosing_namespace_path(starting_node, ancestors:)
+        ancestors.select { |n| [CLASS, MODULE].include?(type(n)) }
+          .each_with_object([]) do |node, namespace|
+          # when evaluating `class Child < Parent`, the const node for `Parent` is a child of the class
+          # node, so it'll be an ancestor, but `Parent` is not evaluated in the namespace of `Child`, so
+          # we need to skip it here
+          next if type(node) == CLASS && parent_class(node) == starting_node
+
+          namespace.prepend(class_or_module_name(node))
+        end
+      end
+
+      def literal_value(string_or_symbol_node)
+        case type(string_or_symbol_node)
+        when STRING, SYMBOL
+          # (str "foo")
+          #   "'foo'"
+          # (sym :foo)
+          #   ":foo"
+          string_or_symbol_node.children[0]
+        else
+          raise TypeError
+        end
+      end
+
+      def location(node)
+        location = node.location
+        Location.new(location.line, location.column)
+      end
+
+      def method_arguments(method_call_node)
+        raise TypeError unless type(method_call_node) == METHOD_CALL
+
+        # (send (lvar :foo) :bar (int 1))
+        #   "foo.bar(1)"
+        method_call_node.children.slice(2..-1)
+      end
+
+      def method_name(method_call_node)
+        raise TypeError unless type(method_call_node) == METHOD_CALL
+
+        # (send (lvar :foo) :bar (int 1))
+        #   "foo.bar(1)"
+        method_call_node.children[1]
+      end
+
+      def module_name_from_definition(node)
+        case type(node)
+        when CLASS, MODULE
+          # "class My::Class; end"
+          # "module My::Module; end"
+          class_or_module_name(node)
+        when CONSTANT_ASSIGNMENT
+          # "My::Class = ..."
+          # "My::Module = ..."
+          rvalue = node.children.last
+
+          case type(rvalue)
+          when METHOD_CALL
+            # "Class.new"
+            # "Module.new"
+            constant_name(node) if module_creation?(rvalue)
+          when BLOCK
+            # "Class.new do end"
+            # "Module.new do end"
+            constant_name(node) if module_creation?(method_call_node(rvalue))
+          end
+        end
+      end
+
+      def name_location(node)
+        location = node.location
+
+        if location.respond_to?(:name)
+          name = location.name
+          Location.new(name.line, name.column)
+        end
+      end
+
+      def parent_class(class_node)
+        raise TypeError unless type(class_node) == CLASS
+
+        # (class (const nil :Foo) (const nil :Bar) (nil))
+        #   "class Foo < Bar; end"
+        class_node.children[1]
+      end
+
+      def parent_module_name(ancestors:)
+        definitions = ancestors
+          .select { |n| [CLASS, MODULE, CONSTANT_ASSIGNMENT, BLOCK].include?(type(n)) }
+
+        names = definitions.map do |definition|
+          name_part_from_definition(definition)
+        end.compact
+
+        names.empty? ? "Object" : names.reverse.join("::")
+      end
+
+      def type(node)
+        node.type
+      end
+
+      def value_from_hash(hash_node, key)
+        raise TypeError unless type(hash_node) == HASH
+        pair = hash_pairs(hash_node).detect { |pair_node| literal_value(hash_pair_key(pair_node)) == key }
+        hash_pair_value(pair) if pair
+      end
+
+      private
+
+      def hash_pair_key(hash_pair_node)
+        raise TypeError unless type(hash_pair_node) == HASH_PAIR
+
+        # (pair (int 1) (int 2))
+        #   "1 => 2"
+        # (pair (sym :answer) (int 42))
+        #   "answer: 42"
+        hash_pair_node.children[0]
+      end
+
+      def hash_pair_value(hash_pair_node)
+        raise TypeError unless type(hash_pair_node) == HASH_PAIR
+
+        # (pair (int 1) (int 2))
+        #   "1 => 2"
+        # (pair (sym :answer) (int 42))
+        #   "answer: 42"
+        hash_pair_node.children[1]
+      end
+
+      def hash_pairs(hash_node)
+        raise TypeError unless type(hash_node) == HASH
+
+        # (hash (pair (int 1) (int 2)) (pair (int 3) (int 4)))
+        #   "{1 => 2, 3 => 4}"
+        hash_node.children.select { |n| type(n) == HASH_PAIR }
+      end
+
+      def method_call_node(block_node)
+        raise TypeError unless type(block_node) == BLOCK
+
+        # (block (send (lvar :foo) :bar) (args) (int 42))
+        #   "foo.bar do 42 end"
+        block_node.children[0]
+      end
+
+      def module_creation?(node)
+        # "Class.new"
+        # "Module.new"
+        type(node) == METHOD_CALL &&
+          type(receiver(node)) == CONSTANT &&
+          ["Class", "Module"].include?(constant_name(receiver(node))) &&
+          method_name(node) == :new
+      end
+
+      def name_from_block_definition(node)
+        if method_name(method_call_node(node)) == :class_eval
+          receiver = receiver(node)
+          constant_name(receiver) if receiver && type(receiver) == CONSTANT
+        end
+      end
+
+      def name_part_from_definition(node)
+        case type(node)
+        when CLASS, MODULE, CONSTANT_ASSIGNMENT
+          module_name_from_definition(node)
+        when BLOCK
+          name_from_block_definition(node)
+        end
+      end
+
+      def receiver(method_call_or_block_node)
+        case type(method_call_or_block_node)
+        when METHOD_CALL
+          method_call_or_block_node.children[0]
+        when BLOCK
+          receiver(method_call_node(method_call_or_block_node))
+        else
+          raise TypeError
+        end
+      end
+    end
+  end
+end