rubocop-nueca 1.0.0 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4a58e87bfcf5ac18b1e87c51da6a3fd4b37e53c664ec86518ae05c5275b446b2
-  data.tar.gz: 9f08cc06b6f03c0bd16ab76fd3b66e2540f2e4c1ba06d23a02f0bffe49c778fa
+  metadata.gz: 6cd3d37c24acab5f66947faec9dde637103acfa42f660988f38ea7354e605f2c
+  data.tar.gz: 788b97be9c8bed6dfbcf2782ee80b779e2dcda463a693a1a2bff8faadb91ef4f
 SHA512:
-  metadata.gz: 436c241836f68bd0136f66d6639ea08c2d8e935583609a421c1045222903aff380a4553df6169dd9131e7e6fddeaf82110a003e4050f0966c1955bbcaa8d3d33
-  data.tar.gz: 27fb4e271c37e2ee980669e81f8c0237d3314a3fc77ba0310bc2401c75430b99cbe765991c418b848432c3ff20de036e338c09a86d26370171368bcac46aedae
+  metadata.gz: 34d5421a39b74e48d9eb999fe7ef10dd45b6e2868a6f6d2635fa90ecf2f85e1920ab092ff766be2ab920c342d539de2ff31e82945b92f42f3f1330a03d58a188
+  data.tar.gz: 54a9044c2ee9c452c59478be3783402d9b161112b34e06fa11e69b2ff0b4aab1f26afb0fb23aad37faf8cf3b657f412245fd1631db04f80732966be6bf02ae0c

data/lib/rubocop/cop/deprecated/auto_time_definition.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      class AutoTimeDefinition < RuboCop::Cop::Base
+        MSG = 'Use autotime(...) helper instead of using Date, DateTime or Time.'
+        RESTRICT_ON_SEND = [:new, :today, :now].freeze
+
+        def_node_matcher :datetime_usage, <<~PATTERN
+          (send
+            (const nil? {:DateTime | :Time | :Date}) ...)
+        PATTERN
+
+        def on_send(node)
+          return unless node.source_range.source_buffer.name.include?('_spec.rb')
+          return unless datetime_usage(node)
+
+          add_offense(node)
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/deprecated/browser_driver.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Capybara
+      class BrowserDriver < ::RuboCop::Cop::Base
+        MSG = 'Use default driver instead of :browser.'
+
+        def_node_matcher :browser_usage, <<~PATTERN
+          (send _ _ _ (sym :browser) ...)
+        PATTERN
+
+        def on_send(node)
+          return unless node.source_range.source_buffer.name.include?('_spec.rb')
+          return unless browser_usage(node)
+
+          add_offense(node)
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/deprecated/mongoid_needs.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      class MongoidNeeds < RuboCop::Cop::Base
+        extend RuboCop::Cop::AutoCorrector
+
+        SAFETY = :unsafe
+        MSG = 'Add `needs: :mongoid` to RSpec.describe when requiring mongoid_helper.'
+
+        def_node_matcher :require_mongoid_helper, <<~PATTERN
+          (send nil? :require (str "mongoid_helper"))
+        PATTERN
+
+        def_node_matcher :rspec_describe_with_needs, <<~PATTERN
+          (send
+            (const nil? :RSpec) :describe
+            _
+            (hash <(pair (sym :needs) (sym :mongoid)) ...>))
+        PATTERN
+
+        def_node_matcher :rspec_describe_without_needs, <<~PATTERN
+          (send
+            (const nil? :RSpec) :describe
+            _
+            $...)
+        PATTERN
+
+        def on_send(node)
+          buffer = node.source_range.source_buffer
+          return unless buffer.name.include?('_spec.rb')
+          return unless require_mongoid_helper(node)
+
+          root_node = processed_source.ast
+          describe_node = find_rspec_describe(root_node)
+
+          return unless describe_node
+          return if rspec_describe_with_needs(describe_node)
+
+          add_offense(describe_node, message: MSG) do |corrector|
+            autocorrect(corrector, describe_node)
+          end
+        end
+
+        private
+
+        def find_rspec_describe(node)
+          return node if rspec_describe_without_needs(node)
+
+          node.children.each do |child|
+            next unless child.is_a?(Parser::AST::Node)
+
+            result = find_rspec_describe(child)
+            return result if result
+          end
+
+          nil
+        end
+
+        def autocorrect(corrector, node)
+          args = node.arguments
+          last_arg = args.last
+          if args.size == 2 && last_arg.hash_type?
+            hash_node = last_arg
+            last_pair = hash_node.pairs.last
+
+            if last_pair
+              corrector.insert_after(last_pair, ', needs: :mongoid')
+            else
+              corrector.insert_after(hash_node.loc.begin, 'needs: :mongoid')
+            end
+          else
+            corrector.insert_after(last_arg, ', needs: :mongoid')
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/rails/model_association_missing_through.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      class ModelAssociationMissingThrough < RuboCop::Cop::Base
+        MSG = 'Association %<association>s references through %<through>s, ' \
+              'but %<through>s is not defined in this model.'
+        ASSOCIATION_METHODS = [
+          :has_one,
+          :has_many,
+          :has_and_belongs_to_many
+        ].freeze
+
+        def on_class(node)
+          return unless model_class?(node)
+
+          associations = find_associations(node)
+          return if associations.empty?
+
+          check_missing_through_associations(associations)
+        end
+
+        private
+
+        def model_class?(node)
+          parent_class = node.parent_class
+          return false unless parent_class
+
+          parent_name = parent_class.const_name
+          ['ApplicationRecord', 'ActiveRecord::Base'].include?(parent_name)
+        end
+
+        def find_associations(class_node)
+          associations = []
+
+          class_node.body&.each_child_node do |child|
+            next unless child.type == :send
+            next unless association_method?(child)
+
+            associations << {
+              node: child,
+              method: child.method_name,
+              name: association_name(child),
+              through: association_through(child)
+            }
+          end
+
+          associations
+        end
+
+        def association_method?(node)
+          return false unless node.receiver.nil?
+
+          ASSOCIATION_METHODS.include?(node.method_name)
+        end
+
+        def association_name(node)
+          first_arg = node.arguments.first
+          return nil unless first_arg&.sym_type?
+
+          first_arg.value.to_s
+        end
+
+        def association_through(node)
+          options_hash = find_options_hash(node)
+          return nil unless options_hash
+
+          through_pair = options_hash.pairs.find do |pair|
+            pair.key.sym_type? && pair.key.value == :through
+          end
+
+          return nil unless through_pair&.value&.sym_type?
+
+          through_pair.value.value.to_s
+        end
+
+        def find_options_hash(node)
+          node.arguments.find(&:hash_type?)
+        end
+
+        def check_missing_through_associations(associations)
+          defined_associations = associations.to_set { |assoc| assoc[:name] }
+
+          associations.each do |assoc|
+            next unless assoc[:through]
+
+            next if defined_associations.include?(assoc[:through])
+
+            message = format(MSG,
+                             association: assoc[:name],
+                             through: assoc[:through])
+            add_offense(assoc[:node], message: message)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/rails/model_association_sorting.rb

@@ -43,6 +43,7 @@ module RuboCop
               node: child,
               method: child.method_name,
               name: association_name(child),
+              through: association_through(child),
               start_line: source_range.line,
               end_line: source_range.last_line
             }
@@ -64,6 +65,23 @@ module RuboCop
           first_arg.value.to_s
         end
 
+        def association_through(node)
+          options_hash = find_options_hash(node)
+          return nil unless options_hash
+
+          through_pair = options_hash.pairs.find do |pair|
+            pair.key.sym_type? && pair.key.value == :through
+          end
+
+          return nil unless through_pair&.value&.sym_type?
+
+          through_pair.value.value.to_s
+        end
+
+        def find_options_hash(node)
+          node.arguments.find(&:hash_type?)
+        end
+
         def check_association_sorting(associations)
           grouped = associations.group_by { |assoc| assoc[:method] }
 
@@ -75,16 +93,49 @@ module RuboCop
         end
 
         def check_group_sorting(group_associations)
-          names = group_associations.map { |assoc| assoc[:name] }
-          sorted_names = names.sort
+          # Separate associations with and without through
+          through_associations = group_associations.select { |assoc| assoc[:through] }
+          regular_associations = group_associations.reject { |assoc| assoc[:through] }
+
+          # Sort regular associations alphabetically
+          regular_sorted = regular_associations.sort_by { |assoc| assoc[:name] }
+
+          # Build expected order respecting through dependencies
+          expected_order = build_expected_order(regular_sorted, through_associations)
+          actual_order = group_associations.map { |assoc| assoc[:name] }
 
-          return if names == sorted_names
+          return if actual_order == expected_order
 
-          expected_order = sorted_names.join(', ')
-          message = format(MSG, expected: expected_order)
+          expected_order_str = expected_order.join(', ')
+          message = format(MSG, expected: expected_order_str)
 
           add_offense(group_associations.first[:node], message: message)
         end
+
+        def build_expected_order(regular_associations, through_associations)
+          expected = []
+
+          # Add regular associations first, sorted alphabetically
+          regular_associations.each do |assoc|
+            expected << assoc[:name]
+
+            # Add any through associations that depend on this one
+            dependent_through = through_associations.select { |ta| ta[:through] == assoc[:name] }
+            dependent_through.sort_by { |ta| ta[:name] }.each do |ta|
+              expected << ta[:name]
+            end
+          end
+
+          # Add any through associations that don't have dependencies in this group
+          orphaned_through = through_associations.reject do |ta|
+            regular_associations.any? { |ra| ra[:name] == ta[:through] }
+          end
+          orphaned_through.sort_by { |ta| ta[:name] }.each do |ta|
+            expected << ta[:name]
+          end
+
+          expected
+        end
       end
     end
   end

data/lib/rubocop/nueca/version.rb

@@ -2,6 +2,6 @@
 
 module RuboCop
   module Nueca
-    VERSION = '1.0.0'
+    VERSION = '1.1.0'
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rubocop-nueca
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.1.0
 platform: ruby
 authors:
 - Tien
@@ -138,11 +138,15 @@ files:
 - README.md
 - config/default.yml
 - lib/rubocop-nueca.rb
+- lib/rubocop/cop/deprecated/auto_time_definition.rb
+- lib/rubocop/cop/deprecated/browser_driver.rb
+- lib/rubocop/cop/deprecated/mongoid_needs.rb
 - lib/rubocop/cop/rails/date_time_conversion.rb
 - lib/rubocop/cop/rails/date_time_current.rb
 - lib/rubocop/cop/rails/migration_table_variable.rb
 - lib/rubocop/cop/rails/model_association_consistent_spacing.rb
 - lib/rubocop/cop/rails/model_association_grouping.rb
+- lib/rubocop/cop/rails/model_association_missing_through.rb
 - lib/rubocop/cop/rails/model_association_scattering.rb
 - lib/rubocop/cop/rails/model_association_separation.rb
 - lib/rubocop/cop/rails/model_association_sorting.rb