rubocop-packs 0.0.11 → 0.0.12

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: caa9570071b5d3b21d447db0959789fbdf5747b352f5b1d5705bd95f0552f722
-  data.tar.gz: 3e739760cb2850057189f4f355417921b0be120cb723f8444e567bdf86ad7392
+  metadata.gz: 23ba4ef8b1719f4a38ac54f304efb11c88df874e3ba15888ad83fd6e3d0b78e1
+  data.tar.gz: 1b2c369b9f7f34dfa6439724a5b2a4dc39addeb1843f8d24d001a9dc55be1860
 SHA512:
-  metadata.gz: 851f5ca37b72f15b5b763a5272094c0996cd4ae2c1daf6924209eaefc4787e0c9a68c9336c71db949995f7fc95eae89d0597a36af486127d87665b5d7c8431fd
-  data.tar.gz: ebac8a9f6f263d7a3898f12dce5ace40980f52789fe7f6763e56d54ad9de7238b7b0b56eb16bbdbe18af13ddda4b698903c37a11946530c1d2fd4763a4265c96
+  metadata.gz: 16a8330e4f3649d6e37178759e23eb500dec1d152b13b8a46e1c0b33ebb8c6f4369c1e4683d1c8ab44ca58b987cedcb567a7e0692aae80744022cc0496d781c8
+  data.tar.gz: c022df83da7b9c811a0add0c6a13950fbb65b7289f2e687093df1aa2c3900b23aacac0e50f72d3d89deb350d94c055b98a198001692498a394ee31136c3e3e65

data/config/default.yml

@@ -16,3 +16,11 @@ Packs/TypedPublicApi:
 
 Packs/RequireDocumentedPublicApis:
   Enabled: true
+
+PackwerkLite/Privacy:
+  # It is recommended to use packwerk
+  Enabled: false
+
+PackwerkLite/Dependency:
+  # It is recommended to use packwerk
+  Enabled: false

data/lib/rubocop/cop/packs/namespace_convention/desired_zeitwerk_api.rb

@@ -6,6 +6,8 @@ module RuboCop
       class NamespaceConvention < Base
         #
         # This is a private class that represents API that we would prefer to be available somehow in Zeitwerk.
+        # However, the boundaries between systems (packwerk/zeitwerk, rubocop/zeitwerk) are poor in this class, so
+        # that would need to be separated prior to proposing any API changes in zeitwerk.
         #
         class DesiredZeitwerkApi
           extend T::Sig

data/lib/rubocop/cop/packs/require_documented_public_apis.rb

@@ -4,22 +4,21 @@ module RuboCop
   module Cop
     module Packs
       # This cop helps ensure that each pack has a documented public API
+      # The following examples assume this basic setup.
       #
       # @example
       #
       #   # bad
       #   # packs/foo/app/public/foo.rb
       #   class Foo
-      #     sig { void }
-      #     def bar
+      #     def bar; end
       #   end
       #
       #   # packs/foo/app/public/foo.rb
       #   class Foo
       #     # This is a documentation comment.
       #     # It can live below or below a sorbet type signature.
-      #     sig { void }
-      #     def bar
+      #     def bar; end
       #   end
       #
       class RequireDocumentedPublicApis < Style::DocumentationMethod

data/lib/rubocop/cop/packs/typed_public_api.rb

@@ -33,6 +33,13 @@ module RuboCop
         # We can apply this same pattern if we want to use other cops in the context of package protections and prevent clashing.
         #
         extend T::Sig
+
+        sig { params(processed_source: T.untyped).void }
+        def investigate(processed_source)
+          return unless processed_source.path.include?('app/public')
+
+          super
+        end
       end
     end
   end

data/lib/rubocop/cop/packwerk_lite/constant_resolver.rb

@@ -0,0 +1,84 @@
+# typed: strict
+
+module RuboCop
+  module Cop
+    module PackwerkLite
+      #
+      # This is a private class that represents API that we would prefer to be available somehow in Zeitwerk.
+      # However, the boundaries between systems (packwerk/zeitwerk, rubocop/zeitwerk) are poor in this class, so
+      # that would need to be separated prior to proposing any API changes in zeitwerk.
+      #
+      class ConstantResolver
+        extend T::Sig
+
+        class ConstantReference < T::Struct
+          extend T::Sig
+
+          const :constant_name, String
+          const :global_namespace, String
+          const :source_package, ParsePackwerk::Package
+          const :constant_definition_location, Pathname
+          const :referencing_file, Pathname
+
+          sig { returns(ParsePackwerk::Package) }
+          def referencing_package
+            ParsePackwerk.package_from_path(referencing_file)
+          end
+
+          sig { returns(T::Boolean) }
+          def public_api?
+            # ParsePackwerk::Package should have a method to take in a path and determine if the file is public.
+            # For now we put it here and only support the public folder (and not specific private constants).
+            constant_definition_location.to_s.include?('/public/')
+          end
+
+          sig { params(node: RuboCop::AST::ConstNode, processed_source: RuboCop::AST::ProcessedSource).returns(T.nilable(ConstantReference)) }
+          def self.resolve(node, processed_source)
+            constant_name = node.const_name
+            namespaces = constant_name.split('::')
+            global_namespace = namespaces.first
+
+            expected_containing_pack_last_name = global_namespace.underscore
+
+            # We don't use ParsePackwerk.find(...) here because we want to look for nested packs, and this pack could be a child pack in a nested pack too.
+            # In the future, we might want `find` to be able to take a glob or a regex to look for packs with a specific name structure.
+            expected_containing_pack = ParsePackwerk.all.find { |p| p.name.include?("/#{expected_containing_pack_last_name}") }
+            return if expected_containing_pack.nil?
+
+            if namespaces.count == 1
+              found_files = expected_containing_pack.directory.glob("app/*/#{expected_containing_pack_last_name}.rb")
+            else
+              expected_location_in_pack = namespaces[1..].map(&:underscore).join('/')
+              found_files = expected_containing_pack.directory.glob("app/*/#{expected_containing_pack_last_name}/#{expected_location_in_pack}.rb")
+            end
+
+            # Because of how Zietwerk works, we know two things:
+            # 1) Since namespaces map one to one with files, Zeitwerk does not permit multiple files to define the same fully-qualified class/module.
+            # (Note it does permit multiple files to open up portions of other namespaces)
+            # 2) If a file *could* define a fully qualified constant, then it *must* define that constant!
+            #
+            # Therefore when we've found possible files, we can sanity check there is only one,
+            # and then assume the found pack defines the constant!
+            raise if found_files.count > 1
+
+            expected_pack_contains_constant = found_files.any?
+
+            return if !expected_pack_contains_constant
+
+            found_file = found_files.first
+
+            ConstantReference.new(
+              constant_name: constant_name,
+              global_namespace: global_namespace,
+              source_package: expected_containing_pack,
+              constant_definition_location: T.must(found_file),
+              referencing_file: Pathname.new(processed_source.path).relative_path_from(Pathname.pwd)
+            )
+          end
+        end
+      end
+
+      private_constant :ConstantResolver
+    end
+  end
+end

data/lib/rubocop/cop/packwerk_lite/dependency_checker.rb

@@ -0,0 +1,77 @@
+# typed: strict
+
+module RuboCop
+  module Cop
+    module PackwerkLite
+      # This cop helps ensure that packs are depending on packs explicitly.
+      #
+      # @example
+      #
+      #   # bad
+      #   # packs/foo/app/services/foo.rb
+      #   class Foo
+      #     def bar
+      #       Bar
+      #     end
+      #   end
+      #
+      #   # packs/foo/package.yml
+      #   # enforces_dependencies: true
+      #   # enforces_privacy: false
+      #   # dependencies:
+      #   #   - packs/baz
+      #
+      #   # good
+      #   # packs/foo/app/services/foo.rb
+      #   class Foo
+      #     def bar
+      #       Bar
+      #     end
+      #   end
+      #
+      #   # packs/foo/package.yml
+      #   # enforces_dependencies: true
+      #   # enforces_privacy: false
+      #   # dependencies:
+      #   #   - packs/baz
+      #   #   - packs/bar
+      #
+      class Dependency < Base
+        extend T::Sig
+
+        sig { returns(T::Boolean) }
+        def support_autocorrect?
+          false
+        end
+
+        sig { params(node: RuboCop::AST::ConstNode).void }
+        def on_const(node)
+          return if Private.partial_const_reference?(node)
+
+          constant_reference = ConstantResolver::ConstantReference.resolve(node, processed_source)
+          return if constant_reference.nil?
+          return if constant_reference.referencing_package.name == constant_reference.source_package.name
+
+          # These are cases that don't work yet!!
+          # I'll need to look into this more. It's related to inflections but not sure how yet!
+          return if constant_reference.constant_name.include?('PncApi')
+
+          is_new_violation = [
+            !constant_reference.referencing_package.dependencies.include?(constant_reference.source_package.name),
+            constant_reference.referencing_package.enforces_dependencies?,
+            !Private.violation_in_deprecated_references_yml?(constant_reference, type: 'dependency')
+          ].all?
+
+          if is_new_violation
+            add_offense(
+              node.source_range,
+              message: format(
+                'Dependency violation detected. See https://github.com/Shopify/packwerk/blob/main/RESOLVING_VIOLATIONS.md for help'
+              )
+            )
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/packwerk_lite/privacy_checker.rb

@@ -0,0 +1,78 @@
+# typed: strict
+
+module RuboCop
+  module Cop
+    module PackwerkLite
+      # This cop helps ensure that packs are using public API of other systems
+      # The following examples assume this basic setup.
+      #
+      # @example
+      #   # packs/bar/app/public/bar.rb
+      #   class Bar
+      #     def my_public_api; end
+      #   end
+      #
+      #   # packs/bar/app/services/private.rb
+      #   class Private
+      #     def my_private_api; end
+      #   end
+      #
+      #   # packs/bar/package.yml
+      #   # enforces_dependencies: false
+      #   # enforces_privacy: true
+      #
+      #   # bad
+      #   # packs/foo/app/services/foo.rb
+      #   class Foo
+      #     def bar
+      #       Private.my_private_api
+      #     end
+      #   end
+      #
+      #   # good
+      #   # packs/foo/app/services/foo.rb
+      #   class Bar
+      #     def bar
+      #       Bar.my_public_api
+      #     end
+      #   end
+      #
+      class Privacy < Base
+        extend T::Sig
+
+        sig { returns(T::Boolean) }
+        def support_autocorrect?
+          false
+        end
+
+        sig { params(node: RuboCop::AST::ConstNode).void }
+        def on_const(node)
+          # See https://github.com/rubocop/rubocop/blob/master/lib/rubocop/cop/lint/constant_resolution.rb source code as an example
+          return if Private.partial_const_reference?(node)
+
+          constant_reference = ConstantResolver::ConstantReference.resolve(node, processed_source)
+
+          # If we can't determine a constant reference, we can just early return. This could be beacuse the constant is defined
+          # in a gem OR because it's not abiding by the namespace convention we've established.
+          return if constant_reference.nil?
+          return if constant_reference.referencing_package.name == constant_reference.source_package.name
+
+          is_new_violation = [
+            !constant_reference.public_api?,
+            constant_reference.source_package.enforces_privacy?,
+            !Private.violation_in_deprecated_references_yml?(constant_reference)
+          ].all?
+
+          if is_new_violation
+            add_offense(
+              node.source_range,
+              message: format(
+                'Privacy violation detected. See https://github.com/Shopify/packwerk/blob/main/RESOLVING_VIOLATIONS.md for help'
+              )
+            )
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/packwerk_lite/private.rb

@@ -0,0 +1,38 @@
+# typed: strict
+
+module RuboCop
+  module Cop
+    module PackwerkLite
+      module Private
+        extend T::Sig
+
+        sig { params(node: RuboCop::AST::ConstNode).returns(T::Boolean) }
+        def self.partial_const_reference?(node)
+          # This is a bit whacky, but if I have a reference in the code like this: Foo::Bar::Baz.any_method, `on_const` will be called three times:
+          # One with `Foo`, one with `Foo::Bar`, and one with `Foo::Bar::Baz`.
+          # As far as I can tell, there is no way to direct Rubocop to only look at the full constant name.
+          # In order to ensure we're only operating on fully constant names, I check the "right sibling" of the `node`, which is the portion of the AST
+          # immediately following the node.
+          # If that right sibling is `nil` OR it's a lowercase string, we assume that it's the full constant.
+          # If the right sibling is a non-nil capitalized string, we assume it's a part of the constant, because by convention, constants
+          # start with capital letters and methods start with lowercase letters.
+          # RegularRateOfPay::Types::HourlyEarningWithDate
+          right_sibling = node.right_sibling
+          return false if right_sibling.nil?
+
+          right_sibling.to_s[0].capitalize == right_sibling.to_s[0]
+        end
+
+        sig { params(constant_reference: ConstantResolver::ConstantReference, type: String).returns(T::Boolean) }
+        def self.violation_in_deprecated_references_yml?(constant_reference, type: 'privacy')
+          existing_violations = ParsePackwerk::DeprecatedReferences.for(constant_reference.referencing_package).violations
+          existing_violations.any? do |v|
+            v.class_name == "::#{constant_reference.constant_name}" && (type == 'privacy' ? v.privacy? : v.dependency?)
+          end
+        end
+      end
+
+      private_constant :Private
+    end
+  end
+end

data/lib/rubocop/packwerk_lite.rb

@@ -0,0 +1,15 @@
+# typed: strict
+# frozen_string_literal: true
+
+require 'rubocop/cop/packwerk_lite/private'
+require 'rubocop/cop/packwerk_lite/constant_resolver'
+require 'rubocop/cop/packwerk_lite/privacy_checker'
+require 'rubocop/cop/packwerk_lite/dependency_checker'
+
+module RuboCop
+  # See docs/packwerk_lite.md
+  module PackwerkLite
+    class Error < StandardError; end
+    extend T::Sig
+  end
+end

data/lib/rubocop-packs.rb

@@ -6,6 +6,7 @@ require 'parse_packwerk'
 
 require_relative 'rubocop/packs'
 require_relative 'rubocop/packs/inject'
+require_relative 'rubocop/packwerk_lite'
 
 require 'rubocop/cop/packs/namespace_convention'
 require 'rubocop/cop/packs/typed_public_api'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rubocop-packs
 version: !ruby/object:Gem::Version
-  version: 0.0.11
+  version: 0.0.12
 platform: ruby
 authors:
 - Gusto Engineers
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2022-10-09 00:00:00.000000000 Z
+date: 2022-10-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -194,10 +194,15 @@ files:
 - lib/rubocop/cop/packs/namespace_convention/desired_zeitwerk_api.rb
 - lib/rubocop/cop/packs/require_documented_public_apis.rb
 - lib/rubocop/cop/packs/typed_public_api.rb
+- lib/rubocop/cop/packwerk_lite/constant_resolver.rb
+- lib/rubocop/cop/packwerk_lite/dependency_checker.rb
+- lib/rubocop/cop/packwerk_lite/privacy_checker.rb
+- lib/rubocop/cop/packwerk_lite/private.rb
 - lib/rubocop/packs.rb
 - lib/rubocop/packs/inject.rb
 - lib/rubocop/packs/private.rb
 - lib/rubocop/packs/private/configuration.rb
+- lib/rubocop/packwerk_lite.rb
 - sorbet/config
 - sorbet/rbi/gems/activesupport@7.0.4.rbi
 - sorbet/rbi/gems/ast@2.4.2.rbi
@@ -261,7 +266,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.7
+rubygems_version: 3.1.6
 signing_key: 
 specification_version: 4
 summary: Fill this out!