Merge pull request rubocop#863 from r7kamura/feature/response-parsed-body

Add `Rails/ResponseParsedBody` cop

Author: koic

changelog/new_add_rails_response_parsed_body_cop.md

@@ -0,0 +1 @@
+* [#863](https://github.com/rubocop/rubocop-rails/pull/863): Add `Rails/ResponseParsedBody` cop. ([@r7kamura][])

config/default.yml

@@ -841,6 +841,17 @@ Rails/RequireDependency:
   Enabled: false
   VersionAdded: '2.10'
 
+Rails/ResponseParsedBody:
+  Description: Prefer `response.parsed_body` to `JSON.parse(response.body)`.
+  Enabled: pending
+  SafeAutoCorrect: false
+  VersionAdded: "<<next>>"
+  Include:
+    - spec/controllers/**/*.rb
+    - spec/requests/**/*.rb
+    - test/controllers/**/*.rb
+    - test/integration/**/*.rb
+
 Rails/ReversibleMigration:
   Description: 'Checks whether the change method of the migration file is reversible.'
   StyleGuide: 'https://rails.rubystyle.guide#reversible-migration'

lib/rubocop/cop/rails/response_parsed_body.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      # Prefer `response.parsed_body` to `JSON.parse(response.body)`.
+      #
+      # @safety
+      #   This cop's autocorrection is unsafe because Content-Type may not be `application/json`. For example, the
+      #   proprietary Content-Type provided by corporate entities such as `application/vnd.github+json` is not
+      #   supported at `response.parsed_body` by default, so you still have to use `JSON.parse(response.body)` there.
+      #
+      # @example
+      #   # bad
+      #   JSON.parse(response.body)
+      #
+      #   # good
+      #   response.parsed_body
+      class ResponseParsedBody < Base
+        extend AutoCorrector
+        extend TargetRailsVersion
+
+        MSG = 'Prefer `response.parsed_body` to `JSON.parse(response.body)`.'
+
+        RESTRICT_ON_SEND = %i[parse].freeze
+
+        minimum_target_rails_version 5.0
+
+        # @!method json_parse_response_body?(node)
+        def_node_matcher :json_parse_response_body?, <<~PATTERN
+          (send
+            (const {nil? cbase} :JSON)
+            :parse
+            (send
+              (send nil? :response)
+              :body
+            )
+          )
+        PATTERN
+
+        def on_send(node)
+          return unless json_parse_response_body?(node)
+
+          add_offense(node) do |corrector|
+            autocorrect(corrector, node)
+          end
+        end
+
+        private
+
+        def autocorrect(corrector, node)
+          corrector.replace(node, 'response.parsed_body')
+        end
+      end
+    end
+  end
+end

lib/rubocop/cop/rails_cops.rb

@@ -99,6 +99,7 @@
 require_relative 'rails/render_plain_text'
 require_relative 'rails/request_referer'
 require_relative 'rails/require_dependency'
+require_relative 'rails/response_parsed_body'
 require_relative 'rails/reversible_migration'
 require_relative 'rails/reversible_migration_method_definition'
 require_relative 'rails/root_join_chain'

spec/rubocop/cop/rails/response_parsed_body_spec.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+RSpec.describe RuboCop::Cop::Rails::ResponseParsedBody, :config do
+  context 'when `response.parsed_body` is used' do
+    it 'registers no offense' do
+      expect_no_offenses(<<~RUBY)
+        expect(response.parsed_body).to eq('foo' => 'bar')
+      RUBY
+    end
+  end
+
+  context 'when Rails version is 4.2 or older', :rails42 do
+    it 'registers no offense' do
+      expect_no_offenses(<<~RUBY)
+        expect(JSON.parse(response.body)).to eq('foo' => 'bar')
+      RUBY
+    end
+  end
+
+  context 'when `JSON.parse(response.body)` is used' do
+    it 'registers offense' do
+      expect_offense(<<~RUBY)
+        expect(JSON.parse(response.body)).to eq('foo' => 'bar')
+               ^^^^^^^^^^^^^^^^^^^^^^^^^ Prefer `response.parsed_body` to `JSON.parse(response.body)`.
+      RUBY
+
+      expect_correction(<<~RUBY)
+        expect(response.parsed_body).to eq('foo' => 'bar')
+      RUBY
+    end
+  end
+
+  context 'when `::JSON.parse(response.body)` is used' do
+    it 'registers offense' do
+      expect_offense(<<~RUBY)
+        expect(::JSON.parse(response.body)).to eq('foo' => 'bar')
+               ^^^^^^^^^^^^^^^^^^^^^^^^^^^ Prefer `response.parsed_body` to `JSON.parse(response.body)`.
+      RUBY
+
+      expect_correction(<<~RUBY)
+        expect(response.parsed_body).to eq('foo' => 'bar')
+      RUBY
+    end
+  end
+end