rubocop-flexport 0.10.0 → 0.10.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1111bda95a88ccde039176a94717252bb9828339ecc9ffef53134068ce9c119a
-  data.tar.gz: c93f725711efde4dd37de393c365c744545c4193e7cc8e433e58f23ca3915768
+  metadata.gz: b6abf69d264c77fa4c789bd8923604ad86b42e583c0ada5b24737cf4d9277d41
+  data.tar.gz: d198d6b916aa148e53f127ed5b74a5d1542c0fb1e9a36907a0e4d08bfc950640
 SHA512:
-  metadata.gz: e8428aff55f6b2bc1bd5b9657942d5f11eb84deb9d98b8e7441db6ff2a6161169e80cfa088b8c0a05e0d54c84643b04b5bc623fa7db1bd728c3f2be17f760d11
-  data.tar.gz: 44ba932445440f9a79e1d5169a62ba41221529d6e5ca3ca69f538776f86fd80727371ad8a7df57045d583f45097ce9024b69d761bb1be756e5a805bda02533be
+  metadata.gz: e121c375c8ee83debb69988c0e60c1014e7b7d136c88a4756bbf81cdf97791824eba9b5c75d91aa2c4b06443b555110e0f8d84462fd856f9a573fef8b4fb3736
+  data.tar.gz: 5e871c97c14af47395c634b9f58fce03e1cdd61eb7a0f47f981e63fd2e208043261edcb55ad2fa2c21c7b75446abe59edc8afac7040f5cfb396ff701e80995d5

data/config/default.yml

@@ -6,6 +6,8 @@ Flexport/EngineApiBoundary:
   UnprotectedEngines: []
   StronglyProtectedEngines: []
   EngineSpecificOverrides: []
+  FactoryBotEnabled: false
+  FactoryBotOutboundAccessAllowedEngines: []
 
 Flexport/GlobalModelAccessFromEngine:
   Description: 'Do not directly access global models from within Rails Engines.'
@@ -16,6 +18,8 @@ Flexport/GlobalModelAccessFromEngine:
   GlobalModelsPath: app/models/
   DisabledEngines: []
   AllowedGlobalModels: []
+  FactoryBotEnabled: false
+  FactoryBotGlobalAccessAllowedEngines: []
   Include:
     - '**/*.rb'
 

data/lib/rubocop/cop/flexport/engine_api_boundary.rb

@@ -43,7 +43,7 @@ module RuboCop
       #
       # The cop will complain if you use FactoryBot factories defined in other
       # engines in your engine's specs. You can disable this check by adding
-      # the engine name to `AllowCrossEngineFactoryBotFromEngines` in
+      # the engine name to `FactoryBotOutboundAccessAllowedEngines` in
       # .rubocop.yml.
       #
       # # Isolation guarantee
@@ -168,10 +168,6 @@ module RuboCop
           (send _ {:belongs_to :has_one :has_many} sym $hash)
         PATTERN
 
-        class << self
-          attr_accessor :factory_engines_cache
-        end
-
         def on_const(node)
           return if in_module_or_class_declaration?(node)
           # There might be value objects that are named
@@ -214,7 +210,7 @@ module RuboCop
         def check_for_cross_engine_factory_bot_usage(node, factory_node)
           factory = factory_node.children[0]
           accessed_engine, model_class_name = factory_engines[factory]
-          return if accessed_engine.nil?
+          return if accessed_engine.nil? || !protected_engines.include?(accessed_engine)
 
           model_class_node = parse_ast(model_class_name)
           return if valid_engine_access?(model_class_node, accessed_engine)
@@ -430,34 +426,34 @@ module RuboCop
           strongly_protected_engines.include?(engine)
         end
 
-        def allow_cross_engine_factory_bot_from_engines
-          @allow_cross_engine_factory_bot_from_engines ||=
-            camelize_all(cop_config['AllowCrossEngineFactoryBotFromEngines'] || [])
+        def factory_bot_outbound_access_allowed_engines
+          @factory_bot_outbound_access_allowed_engines ||=
+            camelize_all(cop_config['FactoryBotOutboundAccessAllowedEngines'] || [])
+        end
+
+        def factory_bot_enabled?
+          cop_config['FactoryBotEnabled']
         end
 
         def check_for_cross_engine_factory_bot?
-          spec_file? && !allow_cross_engine_factory_bot_from_engines.include?(current_engine)
+          spec_file? &&
+            factory_bot_enabled? &&
+            !factory_bot_outbound_access_allowed_engines.include?(current_engine)
         end
 
         # Maps factories to the engine where they are defined.
         def factory_engines
-          # Cache factories at the class level so that we don't have to fetch
-          # them again for every file we lint.
-          self.class.factory_engines_cache ||= spec_factory_paths.each_with_object({}) do |path, h|
+          @factory_engines ||= find_factories.each_with_object({}) do |factory_file, h|
+            path, factories = factory_file
             engine_name = engine_name_from_path(path)
-            ast = parse_ast(File.read(path))
-            find_factories(ast).each do |factory, model_class_name|
+            factories.each do |factory, model_class_name|
               h[factory] = [engine_name, model_class_name]
             end
           end
         end
 
-        def spec_factory_paths
-          @spec_factory_paths ||= Dir["#{engines_path}*/spec/factories/**/*.rb"]
-        end
-
         def spec_factories_modified_time_checksum
-          mtimes = spec_factory_paths.sort.map { |f| File.mtime(f) }
+          mtimes = factory_files.sort.map { |f| File.mtime(f) }
           Digest::SHA1.hexdigest(mtimes.join)
         end
       end

data/lib/rubocop/cop/flexport/global_model_access_from_engine.rb

@@ -47,7 +47,7 @@ module RuboCop
       #
       # This cop will also complain if you try to use global FactoryBot
       # factories in your engine's specs. To disable this behavior for your
-      # engine, add it to the `AllowGlobalFactoryBotFromEngines` list in
+      # engine, add it to the `FactoryBotGlobalAccessAllowedEngines` list in
       # .rubocop.yml.
       #
       class GlobalModelAccessFromEngine < Cop
@@ -61,10 +61,6 @@ module RuboCop
           (send _ {:belongs_to :has_one :has_many} sym $hash)
         PATTERN
 
-        class << self
-          attr_accessor :global_factories_cache
-        end
-
         def on_const(node)
           return unless in_enforced_engine_file?
           return unless global_model_const?(node)
@@ -127,25 +123,14 @@ module RuboCop
         end
 
         def global_factories
-          # Cache factories at the class level so that we don't have to fetch
-          # them again for every file we lint.
-          self.class.global_factories_cache ||= spec_factory_paths.each_with_object({}) do |path, h|
-            source_code = File.read(path)
-            source = RuboCop::ProcessedSource.new(source_code, RUBY_VERSION.to_f)
-            find_factories(source.ast).each do |factory, model_class_name|
-              h[factory] = model_class_name
-            end
-          end
+          @global_factories ||=
+            find_factories.reject { |path| path.start_with?(engines_path) }.values.reduce(:merge)
         end
 
         def model_dir_paths
           Dir[File.join(global_models_path, '**/*.rb')]
         end
 
-        def spec_factory_paths
-          @spec_factory_paths ||= Dir['spec/factories/**/*.rb']
-        end
-
         def calculate_global_models
           all_model_paths = model_dir_paths.reject do |path|
             path.include?('/concerns/')
@@ -182,7 +167,7 @@ module RuboCop
         end
 
         def check_for_global_factory_bot?
-          spec_file? && allow_global_factory_bot_from_engines.none? do |engine|
+          spec_file? && factory_bot_enabled? && factory_bot_global_access_allowed_engines.none? do |engine|
             processed_source.path.include?(File.join(engines_path, engine, ''))
           end
         end
@@ -223,8 +208,12 @@ module RuboCop
           end
         end
 
-        def allow_global_factory_bot_from_engines
-          cop_config['AllowGlobalFactoryBotFromEngines'] || []
+        def factory_bot_global_access_allowed_engines
+          cop_config['FactoryBotGlobalAccessAllowedEngines'] || []
+        end
+
+        def factory_bot_enabled?
+          cop_config['FactoryBotEnabled']
         end
 
         def allowed_global_models

data/lib/rubocop/cop/mixin/factory_bot_usage.rb

@@ -5,9 +5,12 @@ require 'active_support/inflector'
 module RuboCop
   module Cop
     # Helpers for detecting FactoryBot usage.
+    # rubocop:disable Metrics/ModuleLength
     module FactoryBotUsage
       extend NodePattern::Macros
 
+      Factory = Struct.new('Factory', :name, :aliases, :parent, :model_class_name)
+
       FACTORY_BOT_METHODS = %i[
         attributes_for
         attributes_for_list
@@ -25,36 +28,111 @@ module RuboCop
         (send _ {#{FACTORY_BOT_METHODS.map(&:inspect).join(' ')}} $sym)
       PATTERN
 
+      # Cache factories at the class level so that we don't have to fetch them
+      # again for every file we lint. We use class variables here so that the
+      # cache can be shared by all cops that include this module.
+      # rubocop:disable Style/ClassVars
+      @@factories = nil
+
+      def self.factories_cache
+        @@factories
+      end
+
+      def self.factories_cache=(factories)
+        @@factories = factories
+      end
+      # rubocop:enable Style/ClassVars
+
       def spec_file?
         processed_source&.path&.match?(/_spec\.rb$/) || false
       end
 
-      # Recursively traverses a Parser::AST::Node, returning an array of
-      # [factory_name, model_class_name] 2-tuples.
-      def find_factories(node, model_class_name = nil)
-        factories = []
-        return factories unless node.is_a?(Parser::AST::Node)
+      # Parses factory definition files, returning a hash mapping factory names
+      # to model class names for each file.
+      def find_factories
+        RuboCop::Cop::FactoryBotUsage.factories_cache ||= begin
+          # We'll add factories here as we parse the factory files.
+          @factories = {}
+
+          # We'll add factories that specify a parent here, so we can resolve the
+          # reference to the parent after we have finished parsing all the files.
+          @parents = {}
+
+          # Parse the factory files, then resolve any parent references.
+          traverse_factory_files
+          resolve_parents
+
+          @factories
+        end
+      end
+
+      def factory_files
+        @factory_files ||= Dir['spec/factories/**/*.rb'] + Dir["#{engines_path}*/spec/factories/**/*.rb"]
+      end
+
+      def engines_path
+        raise NotImplementedError
+      end
+
+      private
+
+      def traverse_factory_files
+        factory_files.each do |path|
+          @factories[path] = {}
+          @parents[path] = {}
+
+          source_code = File.read(path)
+          source = RuboCop::ProcessedSource.new(source_code, RUBY_VERSION.to_f)
+          traverse_node(source.ast, path)
+        end
+      end
+
+      def resolve_parents
+        all_factories = @factories.values.reduce(:merge)
+        all_parents = @parents.values.reduce(:merge)
+        @parents.each do |path, parents|
+          parents.each do |factory, parent|
+            parent = all_parents[parent] while all_parents[parent]
+            model_class_name = all_factories[parent]
+            next unless model_class_name
+
+            @factories[path][factory] = model_class_name
+          end
+        end
+      end
+
+      def traverse_node(node, path, parent = nil, model_class_name = nil)
+        return unless node.is_a?(Parser::AST::Node)
 
         factory_node = extract_factory_node(node)
         if factory_node
-          factory_name, aliases, model_class_name = parse_factory_node(factory_node, model_class_name)
+          factory = parse_factory_node(factory_node)
+          parent = determine_parent(factory, parent)
+          model_class_name = determine_model_class_name(factory, model_class_name)
           if factory_node?(node)
-            ([factory_name] + aliases).each do |name|
-              factories << [name, model_class_name]
-            end
+            register_factory(path, factory.name, factory.aliases, parent, model_class_name)
+            return
           end
         end
 
-        factories + node.children.flat_map { |child| find_factories(child, model_class_name) }
+        node.children.each { |child| traverse_node(child, path, parent, model_class_name) }
       end
 
-      private
-
       def extract_factory_node(node)
         return node.children[0] if factory_block?(node)
         return node if factory_node?(node)
       end
 
+      def register_factory(path, factory_name, aliases, parent, model_class_name)
+        ([factory_name] + aliases).each do |name|
+          if parent
+            @parents[path][name] = parent
+          else
+            @factories[path][name] = model_class_name
+          end
+        end
+      end
+
       def factory_block?(node)
         return false if node&.type != :block
 
@@ -65,17 +143,15 @@ module RuboCop
         node&.type == :send && node.children[1] == :factory
       end
 
-      def parse_factory_node(node, model_class_name_from_parent_factory = nil)
+      def parse_factory_node(node)
         factory_name_node, factory_config_node = node.children[2..3]
 
-        factory_name = factory_name_node.children[0]
+        name = factory_name_node.children[0]
         aliases = extract_aliases(factory_config_node)
-        explicit_model_class_name = extract_model_class_name(factory_config_node)
-        model_class_name = explicit_model_class_name ||
-                           model_class_name_from_parent_factory ||
-                           ActiveSupport::Inflector.camelize(factory_name)
+        parent = extract_parent(factory_config_node)
+        model_class_name = extract_model_class_name(factory_config_node)
 
-        [factory_name, aliases, model_class_name]
+        Factory.new(name, aliases, parent, model_class_name)
       end
 
       def extract_aliases(factory_config_hash_node)
@@ -85,6 +161,11 @@ module RuboCop
         aliases_array.children.map(&:value)
       end
 
+      def extract_parent(factory_config_hash_node)
+        parent_node = extract_hash_value(factory_config_hash_node, :parent)
+        parent_node&.value
+      end
+
       def extract_model_class_name(factory_config_hash_node)
         model_class_name_node = extract_hash_value(factory_config_hash_node, :class)
 
@@ -107,6 +188,21 @@ module RuboCop
 
         nil
       end
+
+      def determine_parent(factory, parent_from_surrounding_block)
+        # If the factory specifies an explicit model class name, we don't need
+        # to resolve the parent to determine the model class name.
+        return nil if factory.model_class_name
+
+        factory.parent || parent_from_surrounding_block
+      end
+
+      def determine_model_class_name(factory, model_class_name_from_surrounding_block)
+        factory.model_class_name ||
+          model_class_name_from_surrounding_block ||
+          ActiveSupport::Inflector.camelize(factory.name)
+      end
     end
+    # rubocop:enable Metrics/ModuleLength
   end
 end

data/lib/rubocop/flexport/version.rb

@@ -2,6 +2,6 @@
 
 module RuboCop
   module Flexport
-    VERSION = '0.10.0'
+    VERSION = '0.10.1'
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rubocop-flexport
 version: !ruby/object:Gem::Version
-  version: 0.10.0
+  version: 0.10.1
 platform: ruby
 authors:
 - Flexport Engineering
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2020-07-28 00:00:00.000000000 Z
+date: 2020-07-31 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport