rubocop-flexport 0.4.0 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f0ad53cef118c00bda51659b577dd8a099fb46127d71d90df345a0eb2199aa06
-  data.tar.gz: e94a72b0ed1f9e9ca886b25ca2fa68538edf9b08874398f9fd4e7fe5e2c50f27
+  metadata.gz: e7bfc3b432b328659f2ac2dd842e48c05028482c7538fcd2f03a33dbbee4b561
+  data.tar.gz: b9fade3c98f628825b648b184fba3c6317c94476f2c4de1791bdf2aab7e7b372
 SHA512:
-  metadata.gz: 73d6743b8da7bd0f7a325950dc312ab96c5a8eb2fd643b5fd1df8e419900996d14cddb3745ddbe204712c00d0e1dd2956ba477b95d08473ac9f977a84faf485d
-  data.tar.gz: d7c790e2a061b3ff32f7a447569d465903e28eb8c955a73841d60c2ae240d8212fef34d4ce496a3a098ca09aa2d1fbd777cb817c76173eef1b49fa1759ecaef9
+  metadata.gz: 3a7687a4bf47c4f476006a00c7852d5c008daeb88693949b2ff182e28f46c6344fba487ed6e86cda52fc454a7cc5266ae33b47b98829494c96c8e902746c8faa
+  data.tar.gz: 01561c084ee90550946391998f5a28bf0959a2758ece148762714ccb28bb6db2300c8829c13776544a969fab377b136b47b864a8fab76d50461f0d4af9d821f3

data/config/default.yml

@@ -4,6 +4,7 @@ Flexport/EngineApiBoundary:
   VersionAdded: '0.3.0'
   EnginesPath: 'engines/'
   UnprotectedEngines: []
+  StronglyProtectedEngines: []
   EngineSpecificOverrides: []
 
 Flexport/GlobalModelAccessFromEngine:

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

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+# rubocop:disable Metrics/ClassLength
 module RuboCop
   module Cop
     module Flexport
@@ -80,6 +81,36 @@ module RuboCop
       # end
       # ```
       #
+      # # "StronglyProtectedEngines" parameter
+      #
+      # The Engine API is not actually a network API surface. Method invocations
+      # may happen synchronously and assume they are part of the same
+      # transaction. So if your engine is using modules whitelisted by
+      # other engines, then you cannot extract your engine code into a
+      # separate network-isolated service (even though within a big Rails
+      # monolith using engines the cross-engine method call might have been
+      # acceptable).
+      #
+      # The "StronglyProtectedEngines" parameter helps in the case you want to
+      # extract your engine completely. If your engine is listed as a strongly
+      # protected engine, then the following additional restricts apply:
+      #
+      # (1) Any use of your engine's code by code outside your engine is
+      #     considered a violation, regardless of *your* _legacy_dependents.rb,
+      #     _whitelist.rb, or engine API module. (no inbound access)
+      # (2) Any use of other engines' code within your engine is considered
+      #     a violation, regardless of *their* _legacy_dependents.rb,
+      #     _whitelist.rb, or engine API module. (no outbound access)
+      #
+      # (Note: "EngineSpecificOverrides" parameter still has effect.)
+      #
+      # # "EngineSpecificOverrides" parameter
+      #
+      # This parameter allows defining bi-lateral private "APIs" between
+      # engines. See example in global_model_access_from_engine_spec.rb.
+      # This may be useful if you plan to extract several engines into the
+      # same network-isolated service.
+      #
       # @example
       #
       #   # bad
@@ -109,25 +140,27 @@ module RuboCop
       #
       class EngineApiBoundary < Cop
         include EngineApi
+        include EngineNodeContext
 
         MSG = 'Direct access of %<engine>s engine. ' \
               'Only access engine via %<engine>s::Api.'
 
+        STRONGLY_PROTECTED_MSG = 'All direct access of ' \
+              '%<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 ' \
+              'is in the StronglyProtectedEngines list.'
+
         def_node_matcher :rails_association_hash_args, <<-PATTERN
           (send _ {:belongs_to :has_one :has_many} sym $hash)
         PATTERN
 
         def on_const(node)
-          # Sometimes modules/class are declared with the same name as an
-          # engine. For example, you might have:
-          #
-          #   /engines/foo
-          #   /app/graph/types/foo
-          #
-          # We ignore instead of yielding false positive for the module
-          # declaration in the latter.
           return if in_module_or_class_declaration?(node)
-          # Similarly, you might have value objects that are named
+          # There might be value objects that are named
           # the same as engines like:
           #
           # Warehouse.new
@@ -139,7 +172,7 @@ module RuboCop
           return unless engine
           return if valid_engine_access?(node, engine)
 
-          add_offense(node, message: format(MSG, engine: engine))
+          add_offense(node, message: message(node, engine))
         end
 
         def on_send(node)
@@ -151,7 +184,7 @@ module RuboCop
             next if engine.nil?
             next if valid_engine_access?(node, engine)
 
-            add_offense(class_name_node, message: format(MSG, engine: engine))
+            add_offense(class_name_node, message: message(node, engine))
           end
         end
 
@@ -161,6 +194,16 @@ module RuboCop
 
         private
 
+        def message(_node, engine)
+          if strongly_protected_engine?(engine)
+            format(STRONGLY_PROTECTED_MSG, engine: engine)
+          elsif strongly_protected_engine?(current_engine)
+            format(STRONGLY_PROTECTED_CURRENT_MSG, engine: current_engine)
+          else
+            format(MSG, engine: engine)
+          end
+        end
+
         def extract_engine(node)
           return nil unless protected_engines.include?(node.const_name)
 
@@ -192,27 +235,25 @@ module RuboCop
           names.map { |n| ActiveSupport::Inflector.camelize(n) }
         end
 
-        def in_module_or_class_declaration?(node)
-          depth = 0
-          max_depth = 10
-          while node.const_type? && depth < max_depth
-            node = node.parent
-            depth += 1
-          end
-          node.module_type? || node.class_type?
-        end
-
         def sending_method_to_namespace_itself?(node)
           node.parent.send_type?
         end
 
         def valid_engine_access?(node, engine)
+          return true if in_engine_file?(engine)
+          return true if engine_specific_override?(node)
+
+          return false if strongly_protected_engine?(current_engine)
+          return false if strongly_protected_engine?(engine)
+
+          valid_engine_api_access?(node, engine)
+        end
+
+        def valid_engine_api_access?(node, engine)
           (
-            in_engine_file?(engine) ||
             in_legacy_dependent_file?(engine) ||
             through_api?(node) ||
-            whitelisted?(node, engine) ||
-            engine_specific_override?(node)
+            whitelisted?(node, engine)
           )
         end
 
@@ -302,19 +343,31 @@ module RuboCop
 
           raw_overrides.each do |raw_override|
             engine = ActiveSupport::Inflector.camelize(raw_override['Engine'])
-            overrides_by_engine[engine] = raw_override['AllowedModels']
+            overrides_by_engine[engine] = raw_override['AllowedModules']
           end
           overrides_by_engine
         end
 
         def engine_specific_override?(node)
-          model_name = node.parent.source
-          model_names_allowed_by_override = overrides_by_engine[current_engine]
-          return false unless model_names_allowed_by_override
+          module_name = node.parent.source
+          module_names_allowed_by_override = overrides_by_engine[current_engine]
+          return false unless module_names_allowed_by_override
+
+          module_names_allowed_by_override.include?(module_name)
+        end
+
+        def strongly_protected_engines
+          @strongly_protected_engines ||= begin
+            strongly_protected = cop_config['StronglyProtectedEngines'] || []
+            camelize_all(strongly_protected)
+          end
+        end
 
-          model_names_allowed_by_override.include?(model_name)
+        def strongly_protected_engine?(engine)
+          strongly_protected_engines.include?(engine)
         end
       end
     end
   end
 end
+# rubocop:enable Metrics/ClassLength

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

@@ -46,6 +46,8 @@ module RuboCop
       #   end
       #
       class GlobalModelAccessFromEngine < Cop
+        include EngineNodeContext
+
         MSG = 'Direct access of global model `%<model>s` ' \
               'from within Rails Engine.'
 
@@ -58,6 +60,7 @@ module RuboCop
           return unless global_model_const?(node)
           # The cop allows access to e.g. MyGlobalModel::MY_CONST.
           return if child_of_const?(node)
+          return if in_module_or_class_declaration?(node)
 
           add_offense(node, message: message(node.source))
         end

data/lib/rubocop/cop/flexport_cops.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative 'mixin/engine_api'
+require_relative 'mixin/engine_node_context'
 
 require_relative 'flexport/engine_api_boundary'
 require_relative 'flexport/global_model_access_from_engine'

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

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Helpers for determining the context of a node for engine violations.
+    module EngineNodeContext
+      # Sometimes modules/class are declared with the same name as an
+      # engine or global model. For example, you might have both:
+      #
+      #   /engines/foo
+      #   /app/graph/types/foo
+      #
+      # We ignore instead of yielding false positive for the module
+      # declaration in the latter.
+      def in_module_or_class_declaration?(node)
+        depth = 0
+        max_depth = 10
+        while node.const_type? && depth < max_depth
+          node = node.parent
+          depth += 1
+        end
+        node.module_type? || node.class_type?
+      end
+    end
+  end
+end

data/lib/rubocop/flexport/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rubocop-flexport
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.5.0
 platform: ruby
 authors:
 - Flexport Engineering
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2019-12-09 00:00:00.000000000 Z
+date: 2020-01-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -56,6 +56,7 @@ files:
 - lib/rubocop/cop/flexport/new_global_model.rb
 - lib/rubocop/cop/flexport_cops.rb
 - lib/rubocop/cop/mixin/engine_api.rb
+- lib/rubocop/cop/mixin/engine_node_context.rb
 - lib/rubocop/flexport.rb
 - lib/rubocop/flexport/inject.rb
 - lib/rubocop/flexport/version.rb