rubocop-flexport 0.5.0 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e7bfc3b432b328659f2ac2dd842e48c05028482c7538fcd2f03a33dbbee4b561
-  data.tar.gz: b9fade3c98f628825b648b184fba3c6317c94476f2c4de1791bdf2aab7e7b372
+  metadata.gz: 163dbf64bd5550b4f890d2125230be59ba2c1d87e5bf59c513ae206f171852f7
+  data.tar.gz: f7a597e3f5f770d217ea3be631a95cc8b3b16c73e683ef67b775e5195b95ebcd
 SHA512:
-  metadata.gz: 3a7687a4bf47c4f476006a00c7852d5c008daeb88693949b2ff182e28f46c6344fba487ed6e86cda52fc454a7cc5266ae33b47b98829494c96c8e902746c8faa
-  data.tar.gz: 01561c084ee90550946391998f5a28bf0959a2758ece148762714ccb28bb6db2300c8829c13776544a969fab377b136b47b864a8fab76d50461f0d4af9d821f3
+  metadata.gz: '0444612966a40c981dad3f31b02738232d186a112fc06ba167f93f93630346e72ea14ab3bae765c3336bc17797885d604d87ab30935880941d7c7163b47df34c'
+  data.tar.gz: 056f32d4e6da4c4eeabaa41340fa096fc87592a8fe3bf4358357b733a380f667ed21112104bb1e6fec26d66bdb14e71223e6085c0c31e784ebfa16e6947d1652

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

@@ -142,18 +142,20 @@ module RuboCop
         include EngineApi
         include EngineNodeContext
 
-        MSG = 'Direct access of %<engine>s engine. ' \
-              'Only access engine via %<engine>s::Api.'
+        MSG = 'Direct access of %<accessed_engine>s engine. ' \
+              'Only access engine via %<accessed_engine>s::Api.'
 
         STRONGLY_PROTECTED_MSG = 'All direct access of ' \
-              '%<engine>s engine disallowed because ' \
+              '%<accessed_engine>s engine disallowed because ' \
               'it is in StronglyProtectedEngines list.'
 
         STRONGLY_PROTECTED_CURRENT_MSG = 'Direct ' \
-              'access of other engines is disallowed in this file because ' \
-              'it\'s in the %<engine>s engine, which ' \
+              'access of %<accessed_engine>s is disallowed in this file ' \
+              'because it\'s in the %<current_engine>s engine, which ' \
               'is in the StronglyProtectedEngines list.'
 
+        MAIN_APP_NAME = 'MainApp::EngineApi'
+
         def_node_matcher :rails_association_hash_args, <<-PATTERN
           (send _ {:belongs_to :has_one :has_many} sym $hash)
         PATTERN
@@ -168,11 +170,11 @@ module RuboCop
           # We don't want to warn on these cases either.
           return if sending_method_to_namespace_itself?(node)
 
-          engine = extract_engine(node)
-          return unless engine
-          return if valid_engine_access?(node, engine)
+          accessed_engine = extract_accessed_engine(node)
+          return unless accessed_engine
+          return if valid_engine_access?(node, accessed_engine)
 
-          add_offense(node, message: message(node, engine))
+          add_offense(node, message: message(accessed_engine))
         end
 
         def on_send(node)
@@ -180,11 +182,11 @@ module RuboCop
             class_name_node = extract_class_name_node(assocation_hash_args)
             next if class_name_node.nil?
 
-            engine = extract_model_engine(class_name_node)
-            next if engine.nil?
-            next if valid_engine_access?(node, engine)
+            accessed_engine = extract_model_engine(class_name_node)
+            next if accessed_engine.nil?
+            next if valid_engine_access?(node, accessed_engine)
 
-            add_offense(class_name_node, message: message(node, engine))
+            add_offense(class_name_node, message: message(accessed_engine))
           end
         end
 
@@ -194,22 +196,35 @@ module RuboCop
 
         private
 
-        def message(_node, engine)
-          if strongly_protected_engine?(engine)
-            format(STRONGLY_PROTECTED_MSG, engine: engine)
+        def message(accessed_engine)
+          if strongly_protected_engine?(accessed_engine)
+            format(STRONGLY_PROTECTED_MSG, accessed_engine: accessed_engine)
           elsif strongly_protected_engine?(current_engine)
-            format(STRONGLY_PROTECTED_CURRENT_MSG, engine: current_engine)
+            format(
+              STRONGLY_PROTECTED_CURRENT_MSG,
+              accessed_engine: accessed_engine,
+              current_engine: current_engine
+            )
           else
-            format(MSG, engine: engine)
+            format(MSG, accessed_engine: accessed_engine)
           end
         end
 
-        def extract_engine(node)
+        def extract_accessed_engine(node)
+          return MAIN_APP_NAME if disallowed_main_app_access?(node)
           return nil unless protected_engines.include?(node.const_name)
 
           node.const_name
         end
 
+        def disallowed_main_app_access?(node)
+          strongly_protected_engine?(current_engine) && main_app_access?(node)
+        end
+
+        def main_app_access?(node)
+          node.const_name.start_with?(MAIN_APP_NAME)
+        end
+
         def engines_path
           path = cop_config['EnginesPath']
           path += '/' unless path.end_with?('/')
@@ -239,21 +254,21 @@ module RuboCop
           node.parent.send_type?
         end
 
-        def valid_engine_access?(node, engine)
-          return true if in_engine_file?(engine)
+        def valid_engine_access?(node, accessed_engine)
+          return true if in_engine_file?(accessed_engine)
           return true if engine_specific_override?(node)
 
           return false if strongly_protected_engine?(current_engine)
-          return false if strongly_protected_engine?(engine)
+          return false if strongly_protected_engine?(accessed_engine)
 
-          valid_engine_api_access?(node, engine)
+          valid_engine_api_access?(node, accessed_engine)
         end
 
-        def valid_engine_api_access?(node, engine)
+        def valid_engine_api_access?(node, accessed_engine)
           (
-            in_legacy_dependent_file?(engine) ||
+            in_legacy_dependent_file?(accessed_engine) ||
             through_api?(node) ||
-            whitelisted?(node, engine)
+            whitelisted?(node, accessed_engine)
           )
         end
 
@@ -291,12 +306,12 @@ module RuboCop
           end
         end
 
-        def in_engine_file?(engine)
-          current_engine == engine
+        def in_engine_file?(accessed_engine)
+          current_engine == accessed_engine
         end
 
-        def in_legacy_dependent_file?(engine)
-          legacy_dependents = read_api_file(engine, :legacy_dependents)
+        def in_legacy_dependent_file?(accessed_engine)
+          legacy_dependents = read_api_file(accessed_engine, :legacy_dependents)
           # The file names are strings so we need to remove the escaped quotes
           # on either side from the source code.
           legacy_dependents = legacy_dependents.map do |source|

data/lib/rubocop/flexport/version.rb

@@ -2,6 +2,6 @@
 
 module RuboCop
   module Flexport
-    VERSION = '0.5.0'
+    VERSION = '0.6.0'
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rubocop-flexport
 version: !ruby/object:Gem::Version
-  version: 0.5.0
+  version: 0.6.0
 platform: ruby
 authors:
 - Flexport Engineering
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2020-01-30 00:00:00.000000000 Z
+date: 2020-02-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport