rubocop-flexport 0.5.0 → 0.10.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e7bfc3b432b328659f2ac2dd842e48c05028482c7538fcd2f03a33dbbee4b561
-  data.tar.gz: b9fade3c98f628825b648b184fba3c6317c94476f2c4de1791bdf2aab7e7b372
+  metadata.gz: 1111bda95a88ccde039176a94717252bb9828339ecc9ffef53134068ce9c119a
+  data.tar.gz: c93f725711efde4dd37de393c365c744545c4193e7cc8e433e58f23ca3915768
 SHA512:
-  metadata.gz: 3a7687a4bf47c4f476006a00c7852d5c008daeb88693949b2ff182e28f46c6344fba487ed6e86cda52fc454a7cc5266ae33b47b98829494c96c8e902746c8faa
-  data.tar.gz: 01561c084ee90550946391998f5a28bf0959a2758ece148762714ccb28bb6db2300c8829c13776544a969fab377b136b47b864a8fab76d50461f0d4af9d821f3
+  metadata.gz: e8428aff55f6b2bc1bd5b9657942d5f11eb84deb9d98b8e7441db6ff2a6161169e80cfa088b8c0a05e0d54c84643b04b5bc623fa7db1bd728c3f2be17f760d11
+  data.tar.gz: 44ba932445440f9a79e1d5169a62ba41221529d6e5ca3ca69f538776f86fd80727371ad8a7df57045d583f45097ce9024b69d761bb1be756e5a805bda02533be

data/README.md

@@ -43,7 +43,7 @@ like below and then run `bundle install`:
 gem "rubocop-flexport", path: "/Users/<user>/rubocop-flexport"
 ```
 
-To release a new version, update the version number in `version.rb`, and then
+To release a new version, update the version number in `lib/rubocop/flexport/version.rb`, and then
 run `bundle exec rake release`, which will create a git tag for the version,
 push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
 

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

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require 'digest/sha1'
+
 # rubocop:disable Metrics/ClassLength
 module RuboCop
   module Cop
@@ -17,7 +19,7 @@ module RuboCop
       #   will be accessible outside your engine. For example, adding
       #   `api/foo_service.rb` will allow code outside your engine to
       #   invoke eg `MyEngine::Api::FooService.bar(baz)`.
-      # - Create a `_whitelist.rb` file in `api/`. Modules listed in
+      # - Create an `_allowlist.rb` or `_whitelist.rb` file in `api/`. Modules listed in
       #   this file are accessible to code outside the engine. The file
       #   must have this name and a particular format (see below).
       #
@@ -39,6 +41,11 @@ module RuboCop
       # The cop detects cross-engine associations as well as cross-engine
       # module access.
       #
+      # 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
+      # .rubocop.yml.
+      #
       # # Isolation guarantee
       #
       # This cop can be easily circumvented with metaprogramming, so it cannot
@@ -141,23 +148,30 @@ module RuboCop
       class EngineApiBoundary < Cop
         include EngineApi
         include EngineNodeContext
+        include FactoryBotUsage
 
-        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
 
+        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
@@ -168,48 +182,84 @@ 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)
           rails_association_hash_args(node) do |assocation_hash_args|
-            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)
+            check_for_cross_engine_rails_association(node, assocation_hash_args)
+          end
+          return unless check_for_cross_engine_factory_bot?
 
-            add_offense(class_name_node, message: message(node, engine))
+          factory_bot_usage(node) do |factory_node|
+            check_for_cross_engine_factory_bot_usage(node, factory_node)
           end
         end
 
+        def check_for_cross_engine_rails_association(node, assocation_hash_args)
+          class_name_node = extract_class_name_node(assocation_hash_args)
+          return if class_name_node.nil?
+
+          accessed_engine = extract_model_engine(class_name_node)
+          return if accessed_engine.nil?
+          return if valid_engine_access?(node, accessed_engine)
+
+          add_offense(class_name_node, message: message(accessed_engine))
+        end
+
+        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?
+
+          model_class_node = parse_ast(model_class_name)
+          return if valid_engine_access?(model_class_node, accessed_engine)
+
+          add_offense(node, message: message(accessed_engine))
+        end
+
         def external_dependency_checksum
-          engine_api_files_modified_time_checksum(engines_path)
+          checksum = engine_api_files_modified_time_checksum(engines_path)
+          return checksum unless check_for_cross_engine_factory_bot?
+
+          checksum + spec_factories_modified_time_checksum
         end
 
         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?('/')
@@ -236,24 +286,24 @@ module RuboCop
         end
 
         def sending_method_to_namespace_itself?(node)
-          node.parent.send_type?
+          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)
+            allowlisted?(node, accessed_engine)
           )
         end
 
@@ -281,22 +331,23 @@ module RuboCop
         end
 
         def current_engine
-          @current_engine ||= begin
-            file_path = processed_source.path
-            if file_path&.include?(engines_path)
-              parts = file_path.split(engines_path)
-              engine_dir = parts.last.split('/').first
-              ActiveSupport::Inflector.camelize(engine_dir) if engine_dir
-            end
-          end
+          @current_engine ||= engine_name_from_path(processed_source.path)
+        end
+
+        def engine_name_from_path(file_path)
+          return nil unless file_path&.include?(engines_path)
+
+          parts = file_path.split(engines_path)
+          engine_dir = parts.last.split('/').first
+          ActiveSupport::Inflector.camelize(engine_dir) if engine_dir
         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|
@@ -311,15 +362,16 @@ module RuboCop
           node.parent&.const_type? && node.parent.children.last == :Api
         end
 
-        def whitelisted?(node, engine)
-          whitelist = read_api_file(engine, :whitelist)
-          return false if whitelist.empty?
+        def allowlisted?(node, engine)
+          allowlist = read_api_file(engine, :allowlist)
+          allowlist = read_api_file(engine, :whitelist) if allowlist.empty?
+          return false if allowlist.empty?
 
           depth = 0
           max_depth = 5
-          while node.const_type? && depth < max_depth
+          while node&.const_type? && depth < max_depth
             full_const_name = remove_leading_colons(node.source)
-            return true if whitelist.include?(full_const_name)
+            return true if allowlist.include?(full_const_name)
 
             node = node.parent
             depth += 1
@@ -349,11 +401,22 @@ module RuboCop
         end
 
         def engine_specific_override?(node)
-          module_name = node.parent.source
-          module_names_allowed_by_override = overrides_by_engine[current_engine]
-          return false unless module_names_allowed_by_override
+          return false unless overrides_for_current_engine
+
+          depth = 0
+          max_depth = 5
+          while node&.const_type? && depth < max_depth
+            module_name = node.source
+            return true if overrides_for_current_engine.include?(module_name)
+
+            node = node.parent
+            depth += 1
+          end
+          false
+        end
 
-          module_names_allowed_by_override.include?(module_name)
+        def overrides_for_current_engine
+          overrides_by_engine[current_engine]
         end
 
         def strongly_protected_engines
@@ -366,6 +429,37 @@ module RuboCop
         def strongly_protected_engine?(engine)
           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'] || [])
+        end
+
+        def check_for_cross_engine_factory_bot?
+          spec_file? && !allow_cross_engine_factory_bot_from_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|
+            engine_name = engine_name_from_path(path)
+            ast = parse_ast(File.read(path))
+            find_factories(ast).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) }
+          Digest::SHA1.hexdigest(mtimes.join)
+        end
       end
     end
   end

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

@@ -45,8 +45,14 @@ module RuboCop
       #     # No direct association to global models.
       #   end
       #
+      # 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
+      # .rubocop.yml.
+      #
       class GlobalModelAccessFromEngine < Cop
         include EngineNodeContext
+        include FactoryBotUsage
 
         MSG = 'Direct access of global model `%<model>s` ' \
               'from within Rails Engine.'
@@ -55,6 +61,10 @@ 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)
@@ -69,19 +79,41 @@ module RuboCop
           return unless in_enforced_engine_file?
 
           rails_association_hash_args(node) do |assocation_hash_args|
-            class_name_node = extract_class_name_node(assocation_hash_args)
-            class_name = class_name_node&.value
-            next unless global_model?(class_name)
+            check_for_rails_association_with_global_model(assocation_hash_args)
+          end
+
+          return unless check_for_global_factory_bot?
 
-            add_offense(class_name_node, message: message(class_name))
+          factory_bot_usage(node) do |factory_node|
+            check_for_global_factory_bot_usage(node, factory_node)
           end
         end
 
+        def check_for_rails_association_with_global_model(assocation_hash_args)
+          class_name_node = extract_class_name_node(assocation_hash_args)
+          class_name = class_name_node&.value
+          return unless global_model?(class_name)
+
+          add_offense(class_name_node, message: message(class_name))
+        end
+
+        def check_for_global_factory_bot_usage(node, factory_node)
+          factory = factory_node.children[0]
+          return unless global_factory?(factory)
+
+          model_class_name = global_factories[factory]
+          add_offense(node, message: message(model_class_name))
+        end
+
         # Because this cop's behavior depends on the state of external files,
         # we override this method to bust the RuboCop cache when those files
         # change.
         def external_dependency_checksum
-          Digest::SHA1.hexdigest(model_dir_paths.join)
+          if check_for_global_factory_bot?
+            Digest::SHA1.hexdigest((model_dir_paths + global_factories.keys.sort).join)
+          else
+            Digest::SHA1.hexdigest(model_dir_paths.join)
+          end
         end
 
         private
@@ -94,10 +126,26 @@ module RuboCop
           @global_model_names ||= calculate_global_models
         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
+        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/')
@@ -127,7 +175,15 @@ module RuboCop
 
         def in_disabled_engine?(file_path)
           disabled_engines.any? do |e|
-            file_path.include?(File.join(engines_path, e))
+            # Add trailing / to engine path to avoid incorrectly
+            # matching engines with similar names
+            file_path.include?(File.join(engines_path, e, ''))
+          end
+        end
+
+        def check_for_global_factory_bot?
+          spec_file? && allow_global_factory_bot_from_engines.none? do |engine|
+            processed_source.path.include?(File.join(engines_path, engine, ''))
           end
         end
 
@@ -142,6 +198,10 @@ module RuboCop
           global_model_names.include?(class_name)
         end
 
+        def global_factory?(factory_name)
+          global_factories.include?(factory_name)
+        end
+
         def child_of_const?(node)
           node.parent.const_type?
         end
@@ -163,6 +223,10 @@ module RuboCop
           end
         end
 
+        def allow_global_factory_bot_from_engines
+          cop_config['AllowGlobalFactoryBotFromEngines'] || []
+        end
+
         def allowed_global_models
           cop_config['AllowedGlobalModels'] || []
         end

data/lib/rubocop/cop/flexport_cops.rb

@@ -2,6 +2,7 @@
 
 require_relative 'mixin/engine_api'
 require_relative 'mixin/engine_node_context'
+require_relative 'mixin/factory_bot_usage'
 
 require_relative 'flexport/engine_api_boundary'
 require_relative 'flexport/global_model_access_from_engine'

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

@@ -10,9 +10,13 @@ module RuboCop
       extend NodePattern::Macros
 
       API_FILE_DETAILS = {
+        allowlist: {
+          file_basename: '_allowlist.rb',
+          array_matcher: :allowlist_array
+        },
         whitelist: {
           file_basename: '_whitelist.rb',
-          array_matcher: :whitelist_array
+          array_matcher: :allowlist_array
         },
         legacy_dependents: {
           file_basename: '_legacy_dependents.rb',
@@ -58,8 +62,7 @@ module RuboCop
         File.join(engines_path, "#{raw_name}/app/api/#{raw_name}/api/")
       end
 
-      def parse_ast(file_path)
-        source_code = File.read(file_path)
+      def parse_ast(source_code)
         source = RuboCop::ProcessedSource.new(source_code, RUBY_VERSION.to_f)
         source.ast
       end
@@ -99,7 +102,7 @@ module RuboCop
         #             s(:const, nil, :Trucking), :LoadTypes)), :freeze)))
         #
         # We want the :begin in the 2nd case, the :module in the 1st case.
-        module_node = parse_ast(path)
+        module_node = parse_ast(File.read(path))
         module_block_node = module_node&.children&.[](1)
         if module_block_node&.begin_type?
           module_block_node
@@ -108,7 +111,7 @@ module RuboCop
         end
       end
 
-      def_node_matcher :whitelist_array, <<-PATTERN
+      def_node_matcher :allowlist_array, <<-PATTERN
           (casgn nil? {:PUBLIC_MODULES :PUBLIC_SERVICES :PUBLIC_CONSTANTS :PUBLIC_TYPES} {$array (send $array ...)})
       PATTERN
 

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

@@ -15,7 +15,7 @@ module RuboCop
       def in_module_or_class_declaration?(node)
         depth = 0
         max_depth = 10
-        while node.const_type? && depth < max_depth
+        while node.const_type? && node.parent && depth < max_depth
           node = node.parent
           depth += 1
         end

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

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+require 'active_support/inflector'
+
+module RuboCop
+  module Cop
+    # Helpers for detecting FactoryBot usage.
+    module FactoryBotUsage
+      extend NodePattern::Macros
+
+      FACTORY_BOT_METHODS = %i[
+        attributes_for
+        attributes_for_list
+        build
+        build_list
+        build_pair
+        build_stubbed
+        build_stubbed_list
+        create
+        create_list
+        create_pair
+      ].freeze
+
+      def_node_matcher :factory_bot_usage, <<~PATTERN
+        (send _ {#{FACTORY_BOT_METHODS.map(&:inspect).join(' ')}} $sym)
+      PATTERN
+
+      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)
+
+        factory_node = extract_factory_node(node)
+        if factory_node
+          factory_name, aliases, model_class_name = parse_factory_node(factory_node, model_class_name)
+          if factory_node?(node)
+            ([factory_name] + aliases).each do |name|
+              factories << [name, model_class_name]
+            end
+          end
+        end
+
+        factories + node.children.flat_map { |child| find_factories(child, 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 factory_block?(node)
+        return false if node&.type != :block
+
+        factory_node?(node.children[0])
+      end
+
+      def factory_node?(node)
+        node&.type == :send && node.children[1] == :factory
+      end
+
+      def parse_factory_node(node, model_class_name_from_parent_factory = nil)
+        factory_name_node, factory_config_node = node.children[2..3]
+
+        factory_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)
+
+        [factory_name, aliases, model_class_name]
+      end
+
+      def extract_aliases(factory_config_hash_node)
+        aliases_array = extract_hash_value(factory_config_hash_node, :aliases)
+        return [] if aliases_array&.type != :array
+
+        aliases_array.children.map(&:value)
+      end
+
+      def extract_model_class_name(factory_config_hash_node)
+        model_class_name_node = extract_hash_value(factory_config_hash_node, :class)
+
+        case model_class_name_node&.type
+        when :const
+          model_class_name_node.source.sub(/^::/, '')
+        when :str
+          model_class_name_node.value.sub(/^::/, '')
+        end
+      end
+
+      def extract_hash_value(node, hash_key)
+        return nil if node&.type != :hash
+
+        pairs = node.children.select { |child| child.type == :pair }
+        pairs.each do |pair|
+          key, value = pair.children
+          return value if key.value == hash_key
+        end
+
+        nil
+      end
+    end
+  end
+end

data/lib/rubocop/flexport/version.rb

@@ -2,6 +2,6 @@
 
 module RuboCop
   module Flexport
-    VERSION = '0.5.0'
+    VERSION = '0.10.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.10.0
 platform: ruby
 authors:
 - Flexport Engineering
-autorequire: 
+autorequire:
 bindir: exe
 cert_chain: []
-date: 2020-01-30 00:00:00.000000000 Z
+date: 2020-07-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -57,6 +57,7 @@ files:
 - lib/rubocop/cop/flexport_cops.rb
 - lib/rubocop/cop/mixin/engine_api.rb
 - lib/rubocop/cop/mixin/engine_node_context.rb
+- lib/rubocop/cop/mixin/factory_bot_usage.rb
 - lib/rubocop/flexport.rb
 - lib/rubocop/flexport/inject.rb
 - lib/rubocop/flexport/version.rb
@@ -64,7 +65,7 @@ homepage: https://github.com/flexport/rubocop-flexport
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -79,9 +80,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.7.6
-signing_key: 
+rubygems_version: 3.1.2
+signing_key:
 specification_version: 4
 summary: RuboCop cops used at Flexport.
 test_files: []