rubocop-nueca 1.0.0 → 1.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4a58e87bfcf5ac18b1e87c51da6a3fd4b37e53c664ec86518ae05c5275b446b2
-  data.tar.gz: 9f08cc06b6f03c0bd16ab76fd3b66e2540f2e4c1ba06d23a02f0bffe49c778fa
+  metadata.gz: 0e3ce6ea4962d0409ef753cd4cfb316f81a8f40228539b62871d968b54df17f2
+  data.tar.gz: 34d40d5a28a407927510a815ce108121d2ab60bfc157ce2eac671af5b3a18c16
 SHA512:
-  metadata.gz: 436c241836f68bd0136f66d6639ea08c2d8e935583609a421c1045222903aff380a4553df6169dd9131e7e6fddeaf82110a003e4050f0966c1955bbcaa8d3d33
-  data.tar.gz: 27fb4e271c37e2ee980669e81f8c0237d3314a3fc77ba0310bc2401c75430b99cbe765991c418b848432c3ff20de036e338c09a86d26370171368bcac46aedae
+  metadata.gz: 10f24a5fd49e0ee7344e4a260fb58af10ff80a6711a828ff76dfc204d7f17177ed79757fcea03488efba7cc46051c9bcb9c2bdf297ddef3207367340caebafab
+  data.tar.gz: c446cf64ec058628f6c7540ee9519844b83e81d28db772524d86438a96d1343407a7a8af5ef8f6172f5cd5e6afe200c66b7089433114af45ed36931625b7dbea

data/.github/workflows/publish.yml

@@ -0,0 +1,52 @@
+name: Publish Gem
+
+on:
+  push:
+    branches: [ master ]
+
+jobs:
+  publish:
+    runs-on: ubuntu-latest
+
+    steps:
+    - uses: actions/checkout@v4
+
+    - name: Set up Ruby
+      uses: ruby/setup-ruby@v1
+      with:
+        ruby-version: '3.4'
+        bundler-cache: true
+
+    - name: Get gem version
+      id: gem_version
+      run: |
+        VERSION=$(ruby -e "require './lib/rubocop/nueca/version'; puts RuboCop::Nueca::VERSION")
+        echo "version=$VERSION" >> $GITHUB_OUTPUT
+
+    - name: Check if version exists on RubyGems
+      id: version_check
+      run: |
+        if gem list -r rubocop-nueca | grep -q "${{ steps.gem_version.outputs.version }}"; then
+          echo "exists=true" >> $GITHUB_OUTPUT
+        else
+          echo "exists=false" >> $GITHUB_OUTPUT
+        fi
+
+    - name: Build gem
+      if: steps.version_check.outputs.exists == 'false'
+      run: gem build *.gemspec
+
+    - name: Publish to RubyGems
+      if: steps.version_check.outputs.exists == 'false'
+      run: |
+        mkdir -p $HOME/.gem
+        touch $HOME/.gem/credentials
+        chmod 0600 $HOME/.gem/credentials
+        printf -- "---\n:rubygems_api_key: ${GEM_HOST_API_KEY}\n" > $HOME/.gem/credentials
+        gem push *.gem
+      env:
+        GEM_HOST_API_KEY: ${{ secrets.RUBYGEMS_AUTH_TOKEN }}
+
+    - name: Skip publishing
+      if: steps.version_check.outputs.exists == 'true'
+      run: echo "Version ${{ steps.gem_version.outputs.version }} already exists on RubyGems. Skipping publish."

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Rails
-      class ModelAssociationSorting < RuboCop::Cop::Base
+      class ModelAssociationSorting < RuboCop::Cop::Base # rubocop:disable Metrics/ClassLength
         MSG = 'Sort associations of the same type alphabetically. Expected order: %<expected>s.'
         ASSOCIATION_METHODS = [
           :belongs_to,
@@ -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,85 @@ module RuboCop
         end
 
         def check_group_sorting(group_associations)
-          names = group_associations.map { |assoc| assoc[:name] }
-          sorted_names = names.sort
+          through_associations = group_associations.select { |assoc| assoc[:through] }
+          regular_associations = group_associations.reject { |assoc| assoc[:through] }
+
+          regular_sorted = regular_associations.sort_by { |assoc| assoc[:name] }
+
+          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)
+          all_associations = regular_associations + through_associations
+          association_lookup = build_association_lookup(all_associations)
+          dependency_graph = build_dependency_graph(all_associations, association_lookup)
+
+          topological_sort_alphabetically(dependency_graph, all_associations.map { |a| a[:name] })
+        end
+
+        def build_association_lookup(associations)
+          associations.index_by { |assoc| assoc[:name] }
+        end
+
+        def build_dependency_graph(associations, lookup)
+          graph = associations.each_with_object({}) { |assoc, deps| deps[assoc[:name]] = [] }
+
+          associations.each do |assoc|
+            graph[assoc[:through]] << assoc[:name] if assoc[:through] && lookup[assoc[:through]]
+          end
+
+          graph
+        end
+
+        def topological_sort_alphabetically(dependency_graph, all_nodes)
+          in_degrees = calculate_in_degrees(dependency_graph, all_nodes)
+          available_nodes = nodes_with_zero_dependencies(in_degrees)
+          result = []
+
+          until available_nodes.empty?
+            current = available_nodes.shift
+            result << current
+
+            process_dependents(current, dependency_graph, in_degrees, available_nodes)
+          end
+
+          result
+        end
+
+        def calculate_in_degrees(dependency_graph, all_nodes)
+          in_degrees = all_nodes.each_with_object({}) { |node, degrees| degrees[node] = 0 }
+
+          dependency_graph.each_value do |dependents|
+            dependents.each { |dependent| in_degrees[dependent] += 1 }
+          end
+
+          in_degrees
+        end
+
+        def nodes_with_zero_dependencies(in_degrees)
+          in_degrees.select { |_node, degree| degree.zero? }.keys.sort
+        end
+
+        def process_dependents(current_node, dependency_graph, in_degrees, available_nodes)
+          dependency_graph[current_node]&.each do |dependent|
+            in_degrees[dependent] -= 1
+
+            insert_alphabetically(available_nodes, dependent) if in_degrees[dependent].zero?
+          end
+        end
+
+        def insert_alphabetically(sorted_array, element)
+          insert_position = sorted_array.bsearch_index { |x| x > element } || sorted_array.length
+          sorted_array.insert(insert_position, element)
+        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.3'
   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.3
 platform: ruby
 authors:
 - Tien
@@ -133,16 +133,21 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- ".github/workflows/publish.yml"
 - CODE_OF_CONDUCT.md
 - LICENSE.txt
 - 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