workitcop 0.3.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d9a1c429544b92ec47ac6a467cef8d26a1bea4c43371299d323441636b0ecbfc
-  data.tar.gz: 255c41e5e4995120ebea4370b3ef9e3a95773614d580b719c17041eec1883df9
+  metadata.gz: 5e5ee2757afa303b953874d6cdb8c968c6943d551e16f55380cfef5566978882
+  data.tar.gz: 4e08d0261c613fd3475f5dd10fe35aae463518d658b554460aa811e4e0d5b269
 SHA512:
-  metadata.gz: 6513c422e88c53f8287f61fbfeedf160232340bebeea000ebfd2389b6d92b6ffa4b4a657d1a6fff5072281b09ebbc413ace375de128eb686605956dd56b4a869
-  data.tar.gz: 5ea74291617530ff065df00d6ecbd3c9a5f339feb446417fae198667249e746f137424028158df6fe4ad91d364dcf6af10fc71725df7e33513e82688afdd5e50
+  metadata.gz: f85c072382c616c5979a1108239eca0b5db038b61a4270a79f9dd6fedf042d2e271eb931cf6bd7d5cf2016d20a4f5e97dfb4acc90c039cf3bc3dff49f36c2147
+  data.tar.gz: 88a58eafe677dbfc33bcd7138ecf78809f3ba8b731f72ecc70884c53e08905273de355a3e002ccbb4dd662a51790de8e5d4512ac72784e0b4b0c3e47551efb3c

data/CHANGELOG.md

@@ -2,6 +2,12 @@
 
 ## Unreleased
 
+## 0.4.0 - 2022-12-12
+
+- Add new `Workit/RSpecCapybaraPredicateMatcher` cop. ([@ydah])
+- Add new `Workit/RSpecMinitestAssertions` cop. ([@ydah])
+- Add new `Workit/RSpecCapybaraMatchStyle` cop. ([@ydah])
+
 ## 0.3.0 - 2022-12-08
 
 - Fix an error for `Workit/RestrictOnSend` when not in class. ([@ydah])

data/config/default.yml

@@ -30,3 +30,21 @@ Workit/RestrictOnSend:
   Description: |
     Check for `RESTRICT_ON_SEND` is defined if `on_send` or `after_send` are defined.
   Enabled: false
+
+Workit/RSpecCapybaraMatchStyle:
+  Description: Checks for usage of deprecated style methods.
+  Enabled: false
+
+Workit/RSpecCapybaraPredicateMatcher:
+  Description: Prefer using predicate matcher over using predicate method directly.
+  Enabled: false
+  Strict: true
+  EnforcedStyle: inflected
+  AllowedExplicitMatchers: []
+  SupportedStyles:
+    - inflected
+    - explicit
+
+Workit/RSpecMinitestAssertions:
+  Description: Check if using Minitest matchers.
+  Enabled: false

data/lib/rubocop/cop/workit/mixin/rspec_explicit_help.rb

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Workit
+      # A helper for `explicit` style
+      module RSpecExplicitHelp
+        include RuboCop::RSpec::Language
+        extend NodePattern::Macros
+
+        MSG_EXPLICIT = "Prefer using `%<predicate_name>s` over " \
+                       "`%<matcher_name>s` matcher."
+        BUILT_IN_MATCHERS = %w[
+          be_truthy be_falsey be_falsy
+          have_attributes have_received
+          be_between be_within
+        ].freeze
+
+        private
+
+        def allowed_explicit_matchers
+          cop_config.fetch("AllowedExplicitMatchers", []) + BUILT_IN_MATCHERS
+        end
+
+        def check_explicit(node)
+          predicate_matcher_block?(node) do |actual, matcher|
+            add_offense(node, message: message_explicit(matcher)) do |corrector|
+              to_node = node.send_node
+              corrector_explicit(corrector, to_node, actual, matcher, to_node)
+            end
+            ignore_node(node.children.first)
+            return
+          end
+
+          return if part_of_ignored_node?(node)
+
+          predicate_matcher?(node) do |actual, matcher|
+            add_offense(node, message: message_explicit(matcher)) do |corrector|
+              corrector_explicit(corrector, node, actual, matcher, matcher)
+            end
+          end
+        end
+
+        # @!method predicate_matcher?(node)
+        def_node_matcher :predicate_matcher?, <<-PATTERN
+          (send
+            (send nil? :expect $!nil?)
+            #Runners.all
+            {$(send nil? #predicate_matcher_name? ...)
+              (block $(send nil? #predicate_matcher_name? ...) ...)})
+        PATTERN
+
+        # @!method predicate_matcher_block?(node)
+        def_node_matcher :predicate_matcher_block?, <<-PATTERN
+          (block
+            (send
+              (send nil? :expect $!nil?)
+              #Runners.all
+              $(send nil? #predicate_matcher_name?))
+            ...)
+        PATTERN
+
+        def predicate_matcher_name?(name)
+          raise ::NotImplementedError
+        end
+
+        def message_explicit(matcher)
+          format(MSG_EXPLICIT,
+                 predicate_name: to_predicate_method(matcher.method_name),
+                 matcher_name: matcher.method_name)
+        end
+
+        def corrector_explicit(corrector, to_node, actual, matcher, block_child)
+          replacement_matcher = replacement_matcher(to_node)
+          corrector.replace(matcher.loc.expression, replacement_matcher)
+          move_predicate(corrector, actual, matcher, block_child)
+          corrector.replace(to_node.loc.selector, "to")
+        end
+
+        def move_predicate(corrector, actual, matcher, block_child)
+          predicate = to_predicate_method(matcher.method_name)
+          args = args_loc(matcher).source
+          block_loc = block_loc(block_child)
+          block = block_loc ? block_loc.source : ""
+
+          corrector.remove(block_loc) if block_loc
+          corrector.insert_after(actual.loc.expression,
+                                 ".#{predicate}" + args + block)
+        end
+
+        def to_predicate_method(matcher)
+          raise ::NotImplementedError
+        end
+
+        def replacement_matcher(node)
+          case [cop_config["Strict"], node.method?(:to)]
+          when [true, true]
+            "be(true)"
+          when [true, false]
+            "be(false)"
+          when [false, true]
+            "be_truthy"
+          when [false, false]
+            "be_falsey"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/workit/mixin/rspec_inflected_help.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Workit
+      # A helper for `inflected` style
+      module RSpecInflectedHelp
+        include RuboCop::RSpec::Language
+        extend NodePattern::Macros
+
+        MSG_INFLECTED = "Prefer using `%<matcher_name>s` matcher over " \
+                        "`%<predicate_name>s`."
+
+        private
+
+        def check_inflected(node)
+          predicate_in_actual?(node) do |predicate, to, matcher|
+            msg = message_inflected(predicate)
+            add_offense(node, message: msg) do |corrector|
+              remove_predicate(corrector, predicate)
+              corrector.replace(node.loc.selector,
+                                true?(to, matcher) ? "to" : "not_to")
+              rewrite_matcher(corrector, predicate, matcher)
+            end
+          end
+        end
+
+        # @!method predicate_in_actual?(node)
+        def_node_matcher :predicate_in_actual?, <<-PATTERN
+          (send
+            (send nil? :expect {
+              (block $(send !nil? #predicate? ...) ...)
+              $(send !nil? #predicate? ...)})
+            $#Runners.all
+            $#boolean_matcher?)
+        PATTERN
+
+        # @!method be_bool?(node)
+        def_node_matcher :be_bool?, <<-PATTERN
+          (send nil? {:be :eq :eql :equal} {true false})
+        PATTERN
+
+        # @!method be_boolthy?(node)
+        def_node_matcher :be_boolthy?, <<-PATTERN
+          (send nil? {:be_truthy :be_falsey :be_falsy :a_truthy_value :a_falsey_value :a_falsy_value})
+        PATTERN
+
+        def boolean_matcher?(node)
+          if cop_config["Strict"]
+            be_boolthy?(node)
+          else
+            be_bool?(node) || be_boolthy?(node)
+          end
+        end
+
+        def predicate?(sym)
+          raise ::NotImplementedError
+        end
+
+        def message_inflected(predicate)
+          format(MSG_INFLECTED,
+                 predicate_name: predicate.method_name,
+                 matcher_name: to_predicate_matcher(predicate.method_name))
+        end
+
+        def to_predicate_matcher(name)
+          raise ::NotImplementedError
+        end
+
+        def remove_predicate(corrector, predicate)
+          range = predicate.loc.dot.with(
+            end_pos: predicate.loc.expression.end_pos
+          )
+
+          corrector.remove(range)
+
+          block_range = block_loc(predicate)
+          corrector.remove(block_range) if block_range
+        end
+
+        def rewrite_matcher(corrector, predicate, matcher)
+          args = args_loc(predicate).source
+          block_loc = block_loc(predicate)
+          block = block_loc ? block_loc.source : ""
+
+          corrector.replace(
+            matcher.loc.expression,
+            to_predicate_matcher(predicate.method_name) + args + block
+          )
+        end
+
+        def true?(to_symbol, matcher)
+          result = case matcher.method_name
+                   when :be, :eq
+                     matcher.first_argument.true_type?
+                   when :be_truthy, :a_truthy_value
+                     true
+                   when :be_falsey, :be_falsy, :a_falsey_value, :a_falsy_value
+                     false
+                   end
+          to_symbol == :to ? result : !result
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/workit/mixin/rspec_predicate_matcher_base.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Workit
+      # Helper methods for Predicate matcher.
+      module RSpecPredicateMatcherBase
+        include ConfigurableEnforcedStyle
+        include RSpecInflectedHelp
+        include RSpecExplicitHelp
+
+        RESTRICT_ON_SEND = %i[to to_not not_to].freeze
+
+        def on_send(node)
+          case style
+          when :inflected
+            check_inflected(node)
+          when :explicit
+            check_explicit(node)
+          end
+        end
+
+        def on_block(node) # rubocop:disable InternalAffairs/NumblockHandler
+          check_explicit(node) if style == :explicit
+        end
+
+        private
+
+        # returns args location with whitespace
+        # @example
+        #   foo 1, 2
+        #      ^^^^^
+        def args_loc(send_node)
+          send_node.loc.selector.end.with(
+            end_pos: send_node.loc.expression.end_pos
+          )
+        end
+
+        # returns block location with whitespace
+        # @example
+        #   foo { bar }
+        #      ^^^^^^^^
+        def block_loc(send_node)
+          parent = send_node.parent
+          return unless parent.block_type?
+
+          send_node.loc.expression.end.with(
+            end_pos: parent.loc.expression.end_pos
+          )
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/workit/rspec_capybara_match_style.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Workit
+      # Checks for usage of deprecated style methods.
+      #
+      # @example when using `assert_style`
+      #   # bad
+      #   page.find(:css, '#first').assert_style(display: 'block')
+      #
+      #   # good
+      #   page.find(:css, '#first').assert_matches_style(display: 'block')
+      #
+      # @example when using `has_style?`
+      #   # bad
+      #   expect(page.find(:css, 'first')
+      #     .has_style?(display: 'block')).to be true
+      #
+      #   # good
+      #   expect(page.find(:css, 'first')
+      #     .matches_style?(display: 'block')).to be true
+      #
+      # @example when using `have_style`
+      #   # bad
+      #   expect(page).to have_style(display: 'block')
+      #
+      #   # good
+      #   expect(page).to match_style(display: 'block')
+      #
+      class RSpecCapybaraMatchStyle < Base
+        extend AutoCorrector
+
+        MSG = "Use `%<good>s` instead of `%<bad>s`."
+        RESTRICT_ON_SEND = %i[assert_style has_style? have_style].freeze
+        PREFERRED_METHOD = {
+          "assert_style" => "assert_matches_style",
+          "has_style?" => "matches_style?",
+          "have_style" => "match_style"
+        }.freeze
+
+        def on_send(node)
+          method_node = node.loc.selector
+          add_offense(method_node) do |corrector|
+            corrector.replace(method_node,
+                              PREFERRED_METHOD[method_node.source])
+          end
+        end
+
+        private
+
+        def message(node)
+          format(MSG, good: PREFERRED_METHOD[node.source], bad: node.source)
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/workit/rspec_capybara_predicate_matcher.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Workit
+      # Prefer using predicate matcher over using predicate method directly.
+      #
+      # Capybara defines magic matchers for predicate methods.
+      # This cop recommends to use the predicate matcher instead of using
+      # predicate method directly.
+      #
+      # @example Strict: true, EnforcedStyle: inflected (default)
+      #   # bad
+      #   expect(foo.matches_css?(bar: 'baz')).to be_truthy
+      #   expect(foo.matches_selector?(bar: 'baz')).to be_truthy
+      #   expect(foo.matches_style?(bar: 'baz')).to be_truthy
+      #   expect(foo.matches_xpath?(bar: 'baz')).to be_truthy
+      #
+      #   # good
+      #   expect(foo).to match_css(bar: 'baz')
+      #   expect(foo).to match_selector(bar: 'baz')
+      #   expect(foo).to match_style(bar: 'baz')
+      #   expect(foo).to match_xpath(bar: 'baz')
+      #
+      #   # also good - It checks "true" strictly.
+      #   expect(foo.matches_style?(bar: 'baz')).to be(true)
+      #
+      # @example Strict: false, EnforcedStyle: inflected
+      #   # bad
+      #   expect(foo.matches_style?(bar: 'baz')).to be_truthy
+      #   expect(foo.matches_style?(bar: 'baz')).to be(true)
+      #
+      #   # good
+      #   expect(foo).to match_style(bar: 'baz')
+      #
+      # @example Strict: true, EnforcedStyle: explicit
+      #   # bad
+      #   expect(foo).to match_style(bar: 'baz')
+      #
+      #   # good - the above code is rewritten to it by this cop
+      #   expect(foo.matches_style?(bar: 'baz')).to be(true)
+      #
+      # @example Strict: false, EnforcedStyle: explicit
+      #   # bad
+      #   expect(foo).to match_style(bar: 'baz')
+      #
+      #   # good - the above code is rewritten to it by this cop
+      #   expect(foo.matches_style?(bar: 'baz')).to be_truthy
+      #
+      class RSpecCapybaraPredicateMatcher < Base
+        extend AutoCorrector
+        include RuboCop::Cop::Workit::RSpecPredicateMatcherBase
+
+        MATCHER_SUFFIX = %w[css selector style xpath].freeze
+        INFLECTED_MATCHER = MATCHER_SUFFIX.each.map do |suffix|
+          "match_#{suffix}"
+        end.freeze
+        EXPLICIT_MATCHER = MATCHER_SUFFIX.each.map do |suffix|
+          "matches_#{suffix}?"
+        end.freeze
+
+        def predicate_matcher_name?(name)
+          name = name.to_s
+          return false if allowed_explicit_matchers.include?(name)
+
+          INFLECTED_MATCHER.include?(name)
+        end
+
+        def to_predicate_matcher(name)
+          name.to_s.sub("matches_", "match_")[0..-2]
+        end
+
+        def predicate?(sym)
+          EXPLICIT_MATCHER.include?(sym.to_s)
+        end
+
+        def to_predicate_method(matcher)
+          "#{matcher.to_s.sub("match_", "matches_")}?"
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/workit/rspec_minitest_assertions.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Workit
+      # Check if using Minitest matchers.
+      #
+      # @example
+      #   # bad
+      #   assert_equal(a, b)
+      #   assert_equal a, b, "must be equal"
+      #   refute_equal(a, b)
+      #
+      #   # good
+      #   expect(a).to eq(b)
+      #   expect(a).to(eq(b), "must be equal")
+      #   expect(a).not_to eq(b)
+      #
+      class RSpecMinitestAssertions < Base
+        extend AutoCorrector
+
+        MSG = "Use `%<prefer>s`."
+        RESTRICT_ON_SEND = %i[assert_equal refute_equal].freeze
+
+        # @!method minitest_assertion(node)
+        def_node_matcher :minitest_assertion, <<-PATTERN
+          (send nil? {:assert_equal :refute_equal} $_ $_ $_?)
+        PATTERN
+
+        def on_send(node)
+          minitest_assertion(node) do |expected, actual, failure_message|
+            prefer = replacement(node, expected, actual, failure_message.first)
+            add_offense(node, message: message(prefer)) do |corrector|
+              corrector.replace(node, prefer)
+            end
+          end
+        end
+
+        private
+
+        def replacement(node, expected, actual, failure_message)
+          runner = node.method?(:assert_equal) ? "to" : "not_to"
+          if failure_message.nil?
+            "expect(#{expected.source}).#{runner} eq(#{actual.source})"
+          else
+            "expect(#{expected.source}).#{runner}(eq(#{actual.source}), " \
+              "#{failure_message.source})"
+          end
+        end
+
+        def message(prefer)
+          format(MSG, prefer: prefer)
+        end
+      end
+    end
+  end
+end

data/lib/workitcop/inject.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "rubocop"
+require "rubocop-rspec"
 
 module Workitcop
   module Inject

data/lib/workitcop/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Workitcop
-  VERSION = "0.3.0"
+  VERSION = "0.4.0"
 end

data/lib/workitcop.rb

@@ -3,10 +3,17 @@
 require_relative "workitcop/inject"
 require_relative "workitcop/version"
 
+require_relative "rubocop/cop/workit/mixin/rspec_explicit_help"
+require_relative "rubocop/cop/workit/mixin/rspec_inflected_help"
+require_relative "rubocop/cop/workit/mixin/rspec_predicate_matcher_base"
+
 require_relative "rubocop/cop/workit/action_args"
 require_relative "rubocop/cop/workit/comittee_assert_schema_confirm"
 require_relative "rubocop/cop/workit/noop_rescue"
 require_relative "rubocop/cop/workit/restrict_on_send"
+require_relative "rubocop/cop/workit/rspec_capybara_match_style"
+require_relative "rubocop/cop/workit/rspec_capybara_predicate_matcher"
+require_relative "rubocop/cop/workit/rspec_minitest_assertions"
 
 module Workitcop
   PROJECT_ROOT = ::Pathname.new(__dir__).parent.expand_path.freeze

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: workitcop
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.4.0
 platform: ruby
 authors:
 - ydah
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2022-12-08 00:00:00.000000000 Z
+date: 2022-12-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rubocop
@@ -40,8 +40,14 @@ files:
 - config/default.yml
 - lib/rubocop/cop/workit/action_args.rb
 - lib/rubocop/cop/workit/comittee_assert_schema_confirm.rb
+- lib/rubocop/cop/workit/mixin/rspec_explicit_help.rb
+- lib/rubocop/cop/workit/mixin/rspec_inflected_help.rb
+- lib/rubocop/cop/workit/mixin/rspec_predicate_matcher_base.rb
 - lib/rubocop/cop/workit/noop_rescue.rb
 - lib/rubocop/cop/workit/restrict_on_send.rb
+- lib/rubocop/cop/workit/rspec_capybara_match_style.rb
+- lib/rubocop/cop/workit/rspec_capybara_predicate_matcher.rb
+- lib/rubocop/cop/workit/rspec_minitest_assertions.rb
 - lib/workitcop.rb
 - lib/workitcop/inject.rb
 - lib/workitcop/version.rb