sevencop 0.1.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b59b9e87fae854412dd7555c8e0afb4d6c8c5e2a4a629ceb0b5840d94bfbd25c
-  data.tar.gz: d2a7a9cf5eb6b2722e44bb1f29f84ff3557e8be03fab8ecfd7441fb5723b64ec
+  metadata.gz: b2c9e682c02d43b65dbeefd01c07c467881b43bb8a1344289f85584f21e998c9
+  data.tar.gz: fd1dd656e25801d5748b28edcb85d0286c042d29d3b2d065761fa030876c492c
 SHA512:
-  metadata.gz: a8be2a642fcda52bb7b779032bb1714366ef300a44fc2b0d435333c0239d16b7aff7802e8a43206a65e105e328c6d42c400fbf132d2baa40eecadbf54e16b177
-  data.tar.gz: 8581bf84c297111f877db7d3e51eeddea2c1000af8ebaae49dbac164f229d9e73f7ef878a4cfe8520d8a40d1ec01954b04eaafe4370a3e7359e78f8573a45715
+  metadata.gz: 60b0f9acd29d904cc77cc7fbc20023fdc050298ef51022802e815287e9fd8ea5a3823f849a718a2b76fe1a563c3932c5e5e553be9e18cdac16cb22d813ff9e30
+  data.tar.gz: ada45750a1964ee08629bdac329029b169f77aa68999c8c7bf3cd0d983e8eacadb9925d0140fb418a1e9cd0f071b9c1d75f0f8b4dd36ff07e0984c0e21c0a673

data/CHANGELOG.md

@@ -2,6 +2,29 @@
 
 ## Unreleased
 
+## 0.4.0 - 2022-06-18
+
+### Added
+
+- Add `Sevencop/OrderField` cop.
+
+### Changed
+
+- Improve performance of `Sevencop/UniquenessValidatorExplicitCaseSensitivity` cop.
+- Improve offense location of `Sevencop/UniquenessValidatorExplicitCaseSensitivity` cop.
+
+## 0.3.0 - 2022-06-18
+
+### Added
+
+- Add `Sevencop/UniquenessValidatorExplicitCaseSensitivity` cop.
+
+## 0.2.0 - 2022-06-07
+
+### Changed
+
+- Correct to enforced operation at `Sevencop/RedundantExistenceCheck`.
+
 ## 0.1.0 - 2022-06-07
 
 ### Added

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    sevencop (0.1.0)
+    sevencop (0.4.0)
       rubocop (>= 1.27)
 
 GEM

data/README.md

@@ -35,6 +35,26 @@ require:
 
 ## Cops
 
+### Sevencop/OrderField
+
+Identifies a String including "field" is passed to `order` or `reorder`.
+
+```ruby
+# bad
+articles.order('field(id, ?)', a)
+
+# good
+articles.order(Arel.sql('field(id, ?)'), a)
+
+# bad
+reorder('field(id, ?)', a)
+
+# good
+reorder(Arel.sql('field(id, ?)'), a)
+```
+
+`Enabled: false` by default.
+
 ### `Sevencop/RedundantExistenceCheck`
 
 Identifies redundant existent check before file operation.
@@ -44,11 +64,36 @@ Identifies redundant existent check before file operation.
 FileUtils.mkdir(a) unless FileTest.exist?(a)
 
 # good
-FileUtils.mkdir(a)
+FileUtils.mkdir_p(a)
 
 # bad
 FileUtils.rm(a) if FileTest.exist?(a)
 
 # good
-FileUtils.rm(a)
+FileUtils.rm_f(a)
 ```
+
+### `Sevencop/UniquenessValidatorExplicitCaseSensitivity`
+
+Identifies use of UniquenessValidator without :case_sensitive option.
+
+```ruby
+# bad
+validates :name, uniqueness: true
+
+# good
+validates :name, uniqueness: { case_sensitive: true }
+
+# good
+validates :name, uniqueness: { case_sensitive: false }
+
+# bad
+validates :name, uniqueness: { allow_nil: true, scope: :user_id }
+
+# good
+validates :name, uniqueness: { allow_nil: true, scope: :user_id, case_sensitive: true }
+```
+
+Useful to keep the same behavior between Rails 6.0 and 6.1 where case insensitive collation is used in MySQL.
+
+`Enabled: false` by default.

data/Rakefile

@@ -24,7 +24,7 @@ task :new_cop, [:cop] do |_task, args|
 
   generator.write_source
   generator.write_spec
-  generator.inject_require(root_file_path: 'lib/rubocop/cop/rails_deprecation_cops.rb')
+  generator.inject_require(root_file_path: 'lib/sevencop.rb')
   generator.inject_config(config_file_path: 'config/default.yml')
 
   puts generator.todo

data/config/default.yml

@@ -1,5 +1,17 @@
+Sevencop/OrderField:
+  Description: Wrap safe SQL String by `Arel.sql`.
+  Enabled: false
+  Safe: false
+  VersionAdded: '0.4'
+
 Sevencop/RedundantExistenceCheck:
   Description: Avoid redundant existent check before file operation.
   Enabled: true
   Safe: false
   VersionAdded: '0.1'
+
+Sevencop/UniquenessValidatorExplicitCaseSensitivity:
+  Description: Specify :case_sensitivity option on use of UniquenessValidator.
+  Enabled: false
+  Safe: false
+  VersionAdded: '0.3'

data/lib/rubocop/cop/sevencop/order_field.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Sevencop
+      # Identifies a String including "field" is passed to `order` or `reorder`.
+      #
+      # @safety
+      #   This cop is unsafe because it can register a false positive.
+      #
+      # @example
+      #
+      #   # bad
+      #   articles.order('field(id, ?)', a)
+      #
+      #   # good
+      #   articles.order(Arel.sql('field(id, ?)'), a)
+      #
+      #   # bad
+      #   reorder('field(id, ?)', a)
+      #
+      #   # good
+      #   reorder(Arel.sql('field(id, ?)'), a)
+      #
+      class OrderField < Base
+        extend AutoCorrector
+
+        MSG = 'Wrap safe SQL String by `Arel.sql`.'
+
+        RESTRICT_ON_SEND = %i[
+          order
+          reorder
+        ].freeze
+
+        ORDER_METHOD_NAMES = RESTRICT_ON_SEND.to_set.freeze
+
+        def_node_matcher :order_with_field?, <<~PATTERN
+          (send
+            _ ORDER_METHOD_NAMES
+            (str /field\(.+\)/)
+            ...
+          )
+        PATTERN
+
+        # @param [RuboCop::AST::SendNode] node
+        def on_send(node)
+          return unless order_with_field?(node)
+
+          first_argument_node = node.arguments.first
+          add_offense(first_argument_node) do |corrector|
+            corrector.replace(
+              node.arguments.first,
+              "Arel.sql(#{first_argument_node.source})"
+            )
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/sevencop/redundant_existence_check.rb

@@ -6,8 +6,7 @@ module RuboCop
       # Identifies redundant existent check before file operation.
       #
       # @safety
-      #   This cop is unsafe because it can register a false positive
-      #   where the check is truly needed.
+      #   This cop is unsafe because it can register a false positive where the check is truly needed.
       #
       # @example
       #
@@ -15,13 +14,13 @@ module RuboCop
       #   FileUtils.mkdir(a) unless FileTest.exist?(a)
       #
       #   # good
-      #   FileUtils.mkdir(a)
+      #   FileUtils.mkdir_p(a)
       #
       #   # bad
-      #   FileUtils.rm(a) if FileTest.exist?(a)
+      #   FileUtils.rm(a) if File.exist?(a)
       #
       #   # good
-      #   FileUtils.rm(a)
+      #   FileUtils.rm_f(a)
       #
       class RedundantExistenceCheck < Base
         extend AutoCorrector
@@ -31,6 +30,11 @@ module RuboCop
           :FileTest,
         ]
 
+        CLASS_NAMES_FOR_OPERATION = ::Set[
+          :File,
+          :FileUtils,
+        ]
+
         METHOD_NAMES_FOR_MAKE = ::Set[
           :makedirs,
           :mkdir,
@@ -40,6 +44,7 @@ module RuboCop
         ]
 
         METHOD_NAMES_FOR_REMOVE = ::Set[
+          :delete,
           :remove,
           :remove_dir,
           :remove_entry,
@@ -52,6 +57,7 @@ module RuboCop
           :rmdir,
           :rmtree,
           :safe_unlink,
+          :unlink,
         ]
 
         METHOD_NAMES_FOR_EXIST = ::Set[
@@ -59,72 +65,120 @@ module RuboCop
           :exists?,
         ]
 
+        METHOD_NAMES_FOR_FORCE_OPERATION = ::Set[
+          :makedirs,
+          :mkdir_p,
+          :mkpath,
+          :rm_f,
+          :rm_rf,
+          :rm_tree,
+          :safe_unlink,
+          :touch,
+        ]
+
+        METHOD_MAPPING_FOR_FORCE_REPLACEMENT = {
+          'FileUtils.mkdir' => 'FileUtils.mkdir_p',
+          'File.delete' => 'FileUtils.rm_f',
+          'File.unlink' => 'FileUtils.rm_f'
+        }.freeze
+
         MSG = 'Avoid redundant existent check before file operation.'
 
         def_node_matcher :make_unless_exist?, <<~PATTERN
           (if
             (send (const nil? CLASS_NAMES_FOR_EXIST) METHOD_NAMES_FOR_EXIST _)
             nil?
-            (send (const nil? :FileUtils) METHOD_NAMES_FOR_MAKE ...)
+            (send (const nil? CLASS_NAMES_FOR_OPERATION) METHOD_NAMES_FOR_MAKE ...)
           )
         PATTERN
 
         def_node_matcher :remove_if_exist?, <<~PATTERN
           (if
             (send (const nil? CLASS_NAMES_FOR_EXIST) METHOD_NAMES_FOR_EXIST _)
-            (send (const nil? :FileUtils) METHOD_NAMES_FOR_REMOVE ...)
+            (send (const nil? CLASS_NAMES_FOR_OPERATION) METHOD_NAMES_FOR_REMOVE ...)
             nil?
           )
         PATTERN
 
         def on_if(node)
-          if redundant_on_if(node)
-            add_offense(node) do |rewriter|
-              remove_if(
-                node: node,
-                rewriter: rewriter
-              )
-            end
-          elsif redundant_on_unless(node)
-            add_offense(node) do |rewriter|
-              remove_unless(
-                node: node,
-                rewriter: rewriter
-              )
-            end
+          return unless redundant_on_if(node) || redundant_on_unless(node)
+
+          add_offense(node) do |corrector|
+            corrector.replace(
+              node.location.expression,
+              enforce(node)
+            )
           end
         end
 
         private
 
-        def redundant_on_if(node)
-          remove_if_exist?(node) && same_argument_on_if(node)
+        def enforce(node)
+          if force_operation?(node)
+            node.if_branch.source
+          elsif force_replaceable_method?(node)
+            enforce_by_replacement(node)
+          else
+            enforce_by_force_option(node)
+          end
         end
 
-        def redundant_on_unless(node)
-          make_unless_exist?(node) && same_argument_on_unless(node)
+        def enforce_by_force_option(node)
+          arguments = node.if_branch.arguments.map(&:source)
+          arguments << 'force: true' unless force_operation?(node)
+          format(
+            '%<receiver>s.%<method_name>s(%<arguments>s)',
+            arguments: arguments.join(', '),
+            method_name: node.if_branch.method_name,
+            receiver: node.if_branch.receiver.source
+          )
         end
 
-        def remove_if(node:, rewriter:)
-          rewriter.replace(
-            node.location.expression,
-            node.children[1].source
+        def enforce_by_replacement(node)
+          format(
+            '%<signature>s(%<arguments>s)',
+            arguments: node.if_branch.arguments.map(&:source).join(', '),
+            signature: METHOD_MAPPING_FOR_FORCE_REPLACEMENT[operation_method_signature(node)]
           )
         end
 
-        def remove_unless(node:, rewriter:)
-          rewriter.replace(
-            node.location.expression,
-            node.children[2].source
-          )
+        def force_operation?(node)
+          force_operation_method_name?(node) || force_operation_argument?(node)
         end
 
-        def same_argument_on_if(node)
-          node.children[0].children[2] == node.children[1].children[2]
+        def force_operation_argument?(node)
+          node.if_branch.last_argument.hash_type? &&
+            node.if_branch.last_argument.pairs.any? do |pair|
+              pair.key.value == :force && pair.value.true_type?
+            end
+        end
+
+        def force_operation_method_name?(node)
+          METHOD_NAMES_FOR_FORCE_OPERATION.include?(node.if_branch.method_name)
+        end
+
+        def redundant_on_if(node)
+          remove_if_exist?(node) && same_argument?(node)
+        end
+
+        def redundant_on_unless(node)
+          make_unless_exist?(node) && same_argument?(node)
+        end
+
+        def force_replaceable_method?(node)
+          METHOD_MAPPING_FOR_FORCE_REPLACEMENT.key?(operation_method_signature(node))
+        end
+
+        def operation_method_signature(node)
+          format(
+            '%<receiver>s.%<method_name>s',
+            method_name: node.if_branch.method_name,
+            receiver: node.if_branch.receiver.source
+          )
         end
 
-        def same_argument_on_unless(node)
-          node.children[0].children[2] == node.children[2].children[2]
+        def same_argument?(node)
+          node.condition.first_argument == node.if_branch.first_argument
         end
       end
     end

data/lib/rubocop/cop/sevencop/uniqueness_validator_explicit_case_sensitivity.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Sevencop
+      # Identifies use of UniquenessValidator without :case_sensitive option.
+      # This is useful to keep the same behavior between Rails 6.0 and 6.1 where case insensitive collation is used in MySQL.
+      #
+      # @safety
+      #   This cop is unsafe because it can register a false positive.
+      #
+      # @example
+      #
+      #   # bad
+      #   validates :name, uniqueness: true
+      #
+      #   # good
+      #   validates :name, uniqueness: { case_sensitive: true }
+      #
+      #   # good
+      #   validates :name, uniqueness: { case_sensitive: false }
+      #
+      #   # bad
+      #   validates :name, uniqueness: { allow_nil: true, scope: :user_id }
+      #
+      #   # good
+      #   validates :name, uniqueness: { allow_nil: true, scope: :user_id, case_sensitive: true }
+      #
+      class UniquenessValidatorExplicitCaseSensitivity < Base
+        extend AutoCorrector
+
+        MSG = 'Specify :case_sensitivity option on use of UniquenessValidator.'
+
+        RESTRICT_ON_SEND = %i[validates].freeze
+
+        def_node_matcher :validates_uniqueness?, <<~PATTERN
+          (send nil? :validates
+            _
+            (hash
+              <
+                (pair
+                  (sym :uniqueness)
+                  {true | (hash ...)}
+                )
+              >
+              ...
+            )
+          )
+        PATTERN
+
+        def_node_matcher :validates_uniqueness_with_case_sensitivity?, <<~PATTERN
+          (send nil? :validates
+            _
+            (hash
+              <
+                (pair
+                  (sym :uniqueness)
+                  (hash <(pair (sym :case_sensitive) _) ...>)
+                )
+                ...
+              >
+            )
+          )
+        PATTERN
+
+        # @param [RuboCop::AST::SendNode] node
+        def on_send(node)
+          return unless validates_uniqueness?(node) && !validates_uniqueness_with_case_sensitivity?(node)
+
+          uniqueness_value = find_uniqueness_value(node)
+          add_offense(uniqueness_value) do |corrector|
+            if uniqueness_value.true_type?
+              corrector.replace(
+                uniqueness_value.source_range,
+                '{ case_sensitive: true }'
+              )
+            else
+              corrector.insert_after(
+                uniqueness_value.pairs.last.source_range,
+                ', case_sensitive: true'
+              )
+            end
+          end
+        end
+
+        # @param [RuboCop::AST::SendNode] node
+        # @param [RuboCop::AST::Node]
+        def find_uniqueness_value(node)
+          node.arguments[1].pairs.find { |pair| pair.key.value == :uniqueness }.value
+        end
+      end
+    end
+  end
+end

data/lib/sevencop/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Sevencop
-  VERSION = '0.1.0'
+  VERSION = '0.4.0'
 end

data/lib/sevencop.rb

@@ -6,7 +6,9 @@ require 'yaml'
 require_relative 'sevencop/inject'
 require_relative 'sevencop/version'
 
+require_relative 'rubocop/cop/sevencop/order_field'
 require_relative 'rubocop/cop/sevencop/redundant_existence_check'
+require_relative 'rubocop/cop/sevencop/uniqueness_validator_explicit_case_sensitivity'
 
 module Sevencop
   PROJECT_ROOT = ::Pathname.new(__dir__).parent.expand_path.freeze

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sevencop
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.4.0
 platform: ruby
 authors:
 - Ryo Nakamura
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2022-06-06 00:00:00.000000000 Z
+date: 2022-06-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rubocop
@@ -41,7 +41,9 @@ files:
 - README.md
 - Rakefile
 - config/default.yml
+- lib/rubocop/cop/sevencop/order_field.rb
 - lib/rubocop/cop/sevencop/redundant_existence_check.rb
+- lib/rubocop/cop/sevencop/uniqueness_validator_explicit_case_sensitivity.rb
 - lib/sevencop.rb
 - lib/sevencop/inject.rb
 - lib/sevencop/version.rb