packwerk 1.0.0

data/lib/packwerk/node_processor.rb

@@ -0,0 +1,49 @@
+# typed: true
+# frozen_string_literal: true
+
+require "packwerk/node"
+require "packwerk/offense"
+
+module Packwerk
+  class NodeProcessor
+    def initialize(reference_extractor:, reference_lister:, filename:, checkers:)
+      @reference_extractor = reference_extractor
+      @reference_lister = reference_lister
+      @filename = filename
+      @checkers = checkers
+    end
+
+    def call(node, ancestors:)
+      case Node.type(node)
+      when Node::METHOD_CALL, Node::CONSTANT
+        reference = @reference_extractor.reference_from_node(node, ancestors: ancestors, file_path: @filename)
+        check_reference(reference, node) if reference
+      end
+    end
+
+    private
+
+    def check_reference(reference, node)
+      return nil unless (message = failed_check(reference))
+
+      constant = reference.constant
+
+      Packwerk::Offense.new(
+        location: Node.location(node),
+        file: @filename,
+        message: <<~EOS
+          #{message}
+          Inference details: this is a reference to #{constant.name} which seems to be defined in #{constant.location}.
+          To receive help interpreting or resolving this error message, see: https://github.com/Shopify/packwerk/blob/main/TROUBLESHOOT.md#Troubleshooting-violations
+        EOS
+      )
+    end
+
+    def failed_check(reference)
+      failing_checker = @checkers.find do |checker|
+        checker.invalid_reference?(reference, @reference_lister)
+      end
+      failing_checker&.message_for(reference)
+    end
+  end
+end

data/lib/packwerk/node_visitor.rb

@@ -0,0 +1,22 @@
+# typed: false
+# frozen_string_literal: true
+
+require "packwerk/node"
+
+module Packwerk
+  class NodeVisitor
+    def initialize(node_processor:)
+      @node_processor = node_processor
+    end
+
+    def visit(node, ancestors:, result:)
+      offense = @node_processor.call(node, ancestors: ancestors)
+      result << offense if offense
+
+      child_ancestors = [node] + ancestors
+      Node.each_child(node) do |child|
+        visit(child, ancestors: child_ancestors, result: result)
+      end
+    end
+  end
+end

data/lib/packwerk/offense.rb

@@ -0,0 +1,44 @@
+# typed: true
+# frozen_string_literal: true
+
+require "parser/source/map"
+require "sorbet-runtime"
+
+require "packwerk/output_styles"
+
+module Packwerk
+  class Offense
+    extend T::Sig
+    extend T::Helpers
+
+    attr_reader :location, :file, :message
+
+    sig do
+      params(file: String, message: String, location: T.nilable(Node::Location))
+        .void
+    end
+    def initialize(file:, message:, location: nil)
+      @location = location
+      @file = file
+      @message = message
+    end
+
+    sig do
+      params(style: T.any(T.class_of(OutputStyles::Plain), T.class_of(OutputStyles::Coloured)))
+        .returns(String)
+    end
+    def to_s(style = OutputStyles::Plain)
+      if location
+        <<~EOS
+          #{style.filename}#{file}#{style.reset}:#{location.line}:#{location.column}
+          #{@message}
+        EOS
+      else
+        <<~EOS
+          #{style.filename}#{file}#{style.reset}
+          #{@message}
+        EOS
+      end
+    end
+  end
+end

data/lib/packwerk/output_styles.rb

@@ -0,0 +1,41 @@
+# typed: true
+# frozen_string_literal: true
+
+module Packwerk
+  module OutputStyles
+    class Plain
+      class << self
+        def reset
+          ""
+        end
+
+        def filename
+          ""
+        end
+
+        def error
+          ""
+        end
+      end
+    end
+
+    # See https://en.wikipedia.org/wiki/ANSI_escape_code#3/4_bit for ANSI escape colour codes
+    class Coloured
+      class << self
+        def reset
+          "\033[m"
+        end
+
+        def filename
+          # 36 is foreground cyan
+          "\033[36m"
+        end
+
+        def error
+          # 31 is foreground red
+          "\033[31m"
+        end
+      end
+    end
+  end
+end

data/lib/packwerk/package.rb

@@ -0,0 +1,56 @@
+# typed: true
+# frozen_string_literal: true
+
+module Packwerk
+  class Package
+    include Comparable
+
+    ROOT_PACKAGE_NAME = "."
+
+    attr_reader :name, :dependencies
+
+    def initialize(name:, config:)
+      @name = name
+      @config = config || {}
+      @dependencies = Array(@config["dependencies"]).freeze
+    end
+
+    def enforce_privacy
+      @config["enforce_privacy"]
+    end
+
+    def enforce_dependencies?
+      @config["enforce_dependencies"] == true
+    end
+
+    def dependency?(package)
+      @dependencies.include?(package.name)
+    end
+
+    def package_path?(path)
+      return true if root?
+      path.start_with?(@name)
+    end
+
+    def public_path
+      @public_path ||= File.join(@name, "app/public/")
+    end
+
+    def public_path?(path)
+      path.start_with?(public_path)
+    end
+
+    def <=>(other)
+      return nil unless other.is_a?(self.class)
+      name <=> other.name
+    end
+
+    def to_s
+      name
+    end
+
+    def root?
+      @name == ROOT_PACKAGE_NAME
+    end
+  end
+end

data/lib/packwerk/package_set.rb

@@ -0,0 +1,59 @@
+# typed: true
+# frozen_string_literal: true
+
+require "pathname"
+
+require "packwerk/package"
+
+module Packwerk
+  class PackageSet
+    include Enumerable
+
+    PACKAGE_CONFIG_FILENAME = "package.yml"
+
+    class << self
+      def load_all_from(root_path, package_pathspec: nil)
+        package_paths = package_paths(root_path, package_pathspec || "**")
+
+        packages = package_paths.map do |path|
+          root_relative = path.dirname.relative_path_from(root_path)
+          Package.new(name: root_relative.to_s, config: YAML.load_file(path))
+        end
+
+        create_root_package_if_none_in(packages)
+
+        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) }
+      end
+
+      def create_root_package_if_none_in(packages)
+        return if packages.any?(&:root?)
+        packages << Package.new(name: Package::ROOT_PACKAGE_NAME, config: nil)
+      end
+    end
+
+    def initialize(packages)
+      # We want to match more specific paths first
+      sorted_packages = packages.sort_by { |package| -package.name.length }
+      @packages = sorted_packages.each_with_object({}) { |package, hash| hash[package.name] = package }
+    end
+
+    def each(&blk)
+      @packages.values.each(&blk)
+    end
+
+    def fetch(name)
+      @packages[name]
+    end
+
+    def package_from_path(file_path)
+      @packages.values.find { |package| package.package_path?(file_path) }
+    end
+  end
+end

data/lib/packwerk/parsed_constant_definitions.rb

@@ -0,0 +1,62 @@
+# typed: true
+# frozen_string_literal: true
+
+require "ast/node"
+
+require "packwerk/node"
+
+module Packwerk
+  class ParsedConstantDefinitions
+    def initialize(root_node:)
+      @local_definitions = {}
+
+      collect_local_definitions_from_root(root_node) if root_node
+    end
+
+    def local_reference?(constant_name, location: nil, namespace_path: [])
+      qualifications = self.class.reference_qualifications(constant_name, namespace_path: namespace_path)
+
+      qualifications.any? do |name|
+        @local_definitions[name] &&
+          @local_definitions[name] != location
+      end
+    end
+
+    # What fully qualified constants can this constant refer to in this context?
+    def self.reference_qualifications(constant_name, namespace_path:)
+      return [constant_name] if constant_name.start_with?("::")
+
+      fully_qualified_constant_name = "::#{constant_name}"
+
+      possible_namespaces = namespace_path.reduce([""]) do |acc, current|
+        acc << acc.last + "::" + current
+      end
+
+      possible_namespaces.map { |namespace| namespace + fully_qualified_constant_name }
+    end
+
+    private
+
+    def collect_local_definitions_from_root(node, current_namespace_path = [])
+      if Node.type(node) == Node::CONSTANT_ASSIGNMENT
+        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 })
+          add_definition(Node.constant_name(tempnode), current_namespace_path, Node.name_location(tempnode))
+        end
+
+        current_namespace_path += Node.class_or_module_name(node).split("::")
+      end
+
+      Node.each_child(node) { |child| collect_local_definitions_from_root(child, current_namespace_path) }
+    end
+
+    def add_definition(constant_name, current_namespace_path, location)
+      fully_qualified_constant = [""].concat(current_namespace_path).push(constant_name).join("::")
+
+      @local_definitions[fully_qualified_constant] = location
+    end
+  end
+end

data/lib/packwerk/parsers.rb

@@ -0,0 +1,23 @@
+# typed: true
+# frozen_string_literal: true
+
+require "packwerk/offense"
+
+module Packwerk
+  module Parsers
+    autoload :Erb, "packwerk/parsers/erb"
+    autoload :Factory, "packwerk/parsers/factory"
+    autoload :Ruby, "packwerk/parsers/ruby"
+
+    class ParseResult < Offense; end
+
+    class ParseError < StandardError
+      attr_reader :result
+
+      def initialize(result)
+        super(result.message)
+        @result = result
+      end
+    end
+  end
+end

data/lib/packwerk/parsers/erb.rb

@@ -0,0 +1,66 @@
+# typed: true
+# frozen_string_literal: true
+
+require "ast/node"
+require "better_html"
+require "better_html/parser"
+require "parser/source/buffer"
+
+require "packwerk/parsers"
+
+module Packwerk
+  module Parsers
+    class Erb
+      def initialize(parser_class: BetterHtml::Parser, ruby_parser: Ruby.new)
+        @parser_class = parser_class
+        @ruby_parser = ruby_parser
+      end
+
+      def call(io:, file_path: "<unknown>")
+        buffer = Parser::Source::Buffer.new(file_path)
+        buffer.source = io.read
+        parser = @parser_class.new(buffer, template_language: :html)
+        to_ruby_ast(parser.ast, file_path)
+      rescue EncodingError => e
+        result = ParseResult.new(file: file_path, message: e.message)
+        raise Parsers::ParseError, result
+      rescue Parser::SyntaxError => e
+        result = ParseResult.new(file: file_path, message: "Syntax error: #{e}")
+        raise Parsers::ParseError, result
+      end
+
+      private
+
+      def to_ruby_ast(erb_ast, file_path)
+        # Note that we're not using the source location (line/column) at the moment, but if we did
+        # care about that, we'd need to tweak this to insert empty lines and spaces so that things
+        # line up with the ERB file
+        code_pieces = code_nodes(erb_ast).map do |node|
+          node.children.first
+        end
+
+        @ruby_parser.call(
+          io: StringIO.new(code_pieces.join("\n")),
+          file_path: file_path,
+        )
+      end
+
+      def code_nodes(node)
+        return enum_for(:code_nodes, node) unless block_given?
+        return unless node.is_a?(::AST::Node)
+
+        yield node if node.type == :code
+
+        # Skip descending into an ERB comment node, which may contain code nodes
+        if node.type == :erb
+          first_child = node.children.first
+          return if first_child&.type == :indicator && first_child&.children&.first == "#"
+        end
+
+        node.children.each do |child|
+          code_nodes(child) { |n| yield n }
+        end
+      end
+    end
+  end
+end

data/lib/packwerk/parsers/factory.rb

@@ -0,0 +1,34 @@
+# typed: true
+# frozen_string_literal: true
+
+require "singleton"
+
+require "packwerk/parsers"
+
+module Packwerk
+  module Parsers
+    class Factory
+      include Singleton
+
+      RUBY_REGEX = %r{
+        # Although not important for regex, these are ordered from most likely to match to least likely.
+        \.(rb|rake|builder|gemspec|ru)\Z
+        |
+        (Gemfile|Rakefile)\Z
+      }x
+      private_constant :RUBY_REGEX
+
+      ERB_REGEX = /\.erb\Z/
+      private_constant :ERB_REGEX
+
+      def for_path(path)
+        case path
+        when RUBY_REGEX
+          @ruby_parser ||= Ruby.new
+        when ERB_REGEX
+          @erb_parser ||= Erb.new
+        end
+      end
+    end
+  end
+end