rubocop-nueca 1.0.0

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

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      class ModelAssociationSeparation < RuboCop::Cop::Base
+        MSG = 'Separate different association types with a blank line.'
+        ASSOCIATION_METHODS = [
+          :belongs_to,
+          :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.size < 2
+
+          check_association_separation(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)
+
+            source_range = child.source_range
+            associations << {
+              node: child,
+              method: child.method_name,
+              start_line: source_range.line,
+              end_line: source_range.last_line
+            }
+          end
+
+          associations.sort_by { |assoc| assoc[:start_line] }
+        end
+
+        def association_method?(node)
+          return false unless node.receiver.nil?
+
+          ASSOCIATION_METHODS.include?(node.method_name)
+        end
+
+        def check_association_separation(associations)
+          associations.each_with_index do |current, index|
+            next_assoc = associations[index + 1]
+            break unless next_assoc
+            next if same_association_type?(current, next_assoc)
+            next if properly_separated?(current, next_assoc)
+
+            add_offense(next_assoc[:node], message: MSG)
+          end
+        end
+
+        def same_association_type?(current, next_assoc)
+          current[:method] == next_assoc[:method]
+        end
+
+        def properly_separated?(current, next_assoc)
+          current_end_line = current[:end_line]
+          next_start_line = next_assoc[:start_line]
+          lines_between = next_start_line - current_end_line - 1
+
+          return true if lines_between >= 2
+
+          if lines_between == 1
+            between_line = current_end_line
+            line_content = processed_source.lines[between_line].strip
+            return line_content.empty?
+          end
+
+          false
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      class ModelAssociationSorting < RuboCop::Cop::Base
+        MSG = 'Sort associations of the same type alphabetically. Expected order: %<expected>s.'
+        ASSOCIATION_METHODS = [
+          :belongs_to,
+          :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.size < 2
+
+          check_association_sorting(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)
+
+            source_range = child.source_range
+            associations << {
+              node: child,
+              method: child.method_name,
+              name: association_name(child),
+              start_line: source_range.line,
+              end_line: source_range.last_line
+            }
+          end
+
+          associations.sort_by { |assoc| assoc[:start_line] }
+        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 check_association_sorting(associations)
+          grouped = associations.group_by { |assoc| assoc[:method] }
+
+          grouped.each_value do |group_associations|
+            next if group_associations.size < 2
+
+            check_group_sorting(group_associations)
+          end
+        end
+
+        def check_group_sorting(group_associations)
+          names = group_associations.map { |assoc| assoc[:name] }
+          sorted_names = names.sort
+
+          return if names == sorted_names
+
+          expected_order = sorted_names.join(', ')
+          message = format(MSG, expected: expected_order)
+
+          add_offense(group_associations.first[:node], message: message)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      class PostgresTimestamp < RuboCop::Cop::Base
+        MSG = 'Use t.timestamptz for better timezone support.'
+        RESTRICT_ON_SEND = [:datetime, :timestamps].freeze
+
+        def_node_matcher :table_datetime_usage, <<~PATTERN
+          (send lvar :datetime ...)
+        PATTERN
+
+        def_node_matcher :table_timestamps_usage, <<~PATTERN
+          (send lvar :timestamps ...)
+        PATTERN
+
+        def on_send(node)
+          return unless in_migration_file?
+          return unless node.receiver&.name == :t
+
+          add_offense(node, message: MSG) if table_datetime_usage(node) || table_timestamps_usage(node)
+        end
+
+        private
+
+        def in_migration_file?
+          processed_source.file_path&.include?('db/migrate/') || false
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+require_relative '../shared/route_collector'
+
+module RuboCop
+  module Cop
+    module Rails
+      class RouteConsistentSpacing < RuboCop::Cop::Base
+        MSG = 'Do not leave blank lines between routes of the same type at the same namespace level.'
+
+        def on_block(node)
+          return unless rails_routes_draw_block?(node)
+
+          routes = collect_routes(node)
+          return if routes.size < 2
+
+          check_consistent_spacing(routes)
+        end
+
+        private
+
+        def rails_routes_draw_block?(node)
+          return false unless node.block_type?
+
+          send_node = node.send_node
+          receiver = send_node.receiver
+          return false unless receiver
+
+          receiver.source == 'Rails.application.routes' && send_node.method_name == :draw
+        end
+
+        def collect_routes(routes_block)
+          collector = RouteCollector.new
+          body = routes_block.body
+          collector.collect(body) if body
+          collector.routes.sort_by { |route| route[:line] }
+        end
+
+        def check_consistent_spacing(routes)
+          routes.each_with_index do |current_route, index|
+            next_route = routes[index + 1]
+            next unless next_route
+            next unless same_type_and_level?(current_route, next_route)
+
+            add_offense(next_route[:node], message: MSG) if blank_line_between?(current_route, next_route)
+          end
+        end
+
+        def same_type_and_level?(current_route, next_route)
+          current_route[:type] == next_route[:type] &&
+            current_route[:namespace_level] == next_route[:namespace_level]
+        end
+
+        def blank_line_between?(current_route, next_route)
+          current_end_line = current_route[:end_line]
+          next_start_line = next_route[:line]
+          lines_between = next_start_line - current_end_line - 1
+
+          lines_between >= 1
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+require_relative '../shared/route_collector'
+
+module RuboCop
+  module Cop
+    module Rails
+      class RouteGrouping < RuboCop::Cop::Base
+        MSG = 'Group routes by type. Keep simple routes, resources, and namespaces grouped together.'
+
+        def on_block(node)
+          return unless rails_routes_draw_block?(node)
+
+          routes = collect_routes(node)
+          return if routes.size < 2
+
+          check_for_scattered_routes(routes)
+        end
+
+        private
+
+        def rails_routes_draw_block?(node)
+          return false unless node.block_type?
+
+          send_node = node.send_node
+          receiver = send_node.receiver
+          return false unless receiver
+
+          receiver.source == 'Rails.application.routes' && send_node.method_name == :draw
+        end
+
+        def collect_routes(routes_block)
+          collector = RouteCollector.new
+          body = routes_block.body
+          collector.collect(body) if body
+          collector.routes.sort_by { |route| route[:line] }
+        end
+
+        def check_for_scattered_routes(routes)
+          routes_by_type_and_context = routes.group_by do |route|
+            [route[:type], route[:namespace_level], route[:namespace_path]]
+          end
+
+          routes_by_type_and_context.each_value do |type_routes|
+            next if type_routes.size < 2
+
+            find_scattered_routes(type_routes, routes).each do |route|
+              add_offense(route[:node], message: MSG)
+            end
+          end
+        end
+
+        def find_scattered_routes(type_routes, all_routes)
+          scattered = []
+
+          type_routes.each_with_index do |current_route, index|
+            next if index.zero?
+
+            if scattered_from_previous?(current_route, type_routes[0...index],
+                                        all_routes) && !scattered.include?(current_route) # rubocop:disable Rails/NegateInclude
+              scattered << current_route
+            end
+          end
+
+          scattered
+        end
+
+        def scattered_from_previous?(current_route, previous_routes, all_routes)
+          current_line = current_route[:line]
+          route_type = current_route[:type]
+          namespace_level = current_route[:namespace_level]
+
+          previous_routes.any? do |prev_route|
+            different_types_between?(all_routes, prev_route[:line], current_line, route_type, namespace_level)
+          end
+        end
+
+        def different_types_between?(all_routes, start_line, end_line, route_type, namespace_level)
+          all_routes.any? do |route|
+            line = route[:line]
+            line > start_line && line < end_line &&
+              route[:namespace_level] == namespace_level && route[:type] != route_type
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+require_relative '../shared/route_collector'
+
+module RuboCop
+  module Cop
+    module Rails
+      class RouteRootPosition < RuboCop::Cop::Base
+        MSG = 'The root route should be positioned at the top of routes within the same namespace level.'
+
+        def on_block(node)
+          return unless rails_routes_draw_block?(node)
+
+          routes = collect_routes(node)
+          return if routes.empty?
+
+          check_root_position(routes)
+        end
+
+        private
+
+        def rails_routes_draw_block?(node)
+          return false unless node.block_type?
+
+          send_node = node.send_node
+          receiver = send_node.receiver
+          return false unless receiver
+
+          receiver.source == 'Rails.application.routes' && send_node.method_name == :draw
+        end
+
+        def collect_routes(routes_block)
+          collector = RouteCollector.new
+          body = routes_block.body
+          collector.collect(body) if body
+          collector.routes.sort_by { |route| route[:line] }
+        end
+
+        def check_root_position(routes)
+          routes_by_context = routes.group_by do |route|
+            [route[:namespace_level], route[:namespace_path]]
+          end
+
+          routes_by_context.each_value do |context_routes|
+            check_root_in_context(context_routes)
+          end
+        end
+
+        def check_root_in_context(context_routes)
+          return if context_routes.size < 2
+
+          root_routes, non_root_routes = partition_routes_by_root(context_routes)
+          return if root_routes.empty?
+
+          non_root_simple_routes = filter_simple_routes(non_root_routes)
+          return if non_root_simple_routes.empty?
+
+          detect_mispositioned_roots(root_routes, non_root_simple_routes)
+        end
+
+        def filter_simple_routes(routes)
+          routes.select { |route| simple_route?(route) }
+        end
+
+        def detect_mispositioned_roots(root_routes, simple_routes)
+          root_routes.each do |root_route|
+            if any_simple_route_before?(root_route, simple_routes)
+              add_offense(root_route[:node], message: MSG)
+              break
+            end
+          end
+        end
+
+        def any_simple_route_before?(root_route, simple_routes)
+          simple_routes.any? { |simple_route| root_route[:line] > simple_route[:line] }
+        end
+
+        def partition_routes_by_root(routes)
+          root_routes = []
+          non_root_routes = []
+
+          routes.each do |route|
+            if root_route?(route)
+              root_routes << route
+            else
+              non_root_routes << route
+            end
+          end
+
+          [root_routes, non_root_routes]
+        end
+
+        def root_route?(route)
+          route[:name] == 'root'
+        end
+
+        def simple_route?(route)
+          route[:type] == :simple
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+require_relative '../shared/route_collector'
+
+module RuboCop
+  module Cop
+    module Rails
+      class RouteSeparation < RuboCop::Cop::Base
+        MSG = 'Separate different route types with a blank line.'
+
+        def on_block(node)
+          return unless rails_routes_draw_block?(node)
+
+          routes = collect_routes(node)
+          return if routes.size < 2
+
+          check_route_separation(routes)
+        end
+
+        private
+
+        def rails_routes_draw_block?(node)
+          return false unless node.block_type?
+
+          send_node = node.send_node
+          receiver = send_node.receiver
+          return false unless receiver
+
+          receiver.source == 'Rails.application.routes' && send_node.method_name == :draw
+        end
+
+        def collect_routes(routes_block)
+          collector = RouteCollector.new
+          body = routes_block.body
+          collector.collect(body) if body
+          collector.routes.sort_by { |route| route[:line] }
+        end
+
+        def check_route_separation(routes)
+          routes_by_context = routes.group_by do |route|
+            [route[:namespace_level], route[:namespace_path]]
+          end
+
+          routes_by_context.each_value do |context_routes|
+            next if context_routes.size < 2
+
+            check_separation_within_context(context_routes)
+          end
+        end
+
+        def check_separation_within_context(routes)
+          routes.each_with_index do |current_route, index|
+            next_route = routes[index + 1]
+            break unless next_route
+            next if same_route_type?(current_route, next_route)
+            next if properly_separated?(current_route, next_route)
+
+            add_offense(next_route[:node], message: MSG)
+          end
+        end
+
+        def same_route_type?(current_route, next_route)
+          current_route[:type] == next_route[:type]
+        end
+
+        def properly_separated?(current_route, next_route)
+          current_end_line = current_route[:end_line]
+          next_start_line = next_route[:line]
+          lines_between = next_start_line - current_end_line - 1
+
+          return true if lines_between >= 2
+
+          if lines_between == 1
+            between_line = current_end_line
+            line_content = processed_source.lines[between_line].strip
+            return line_content.empty?
+          end
+
+          false
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+require_relative '../shared/route_collector'
+
+module RuboCop
+  module Cop
+    module Rails
+      class RouteSorting < RuboCop::Cop::Base
+        MSG = 'Sort routes of the same type alphabetically within the same namespace level. ' \
+              'Expected order: %<expected>s.'
+
+        def on_block(node)
+          return unless rails_routes_draw_block?(node)
+
+          routes = collect_routes(node)
+          return if routes.size < 2
+
+          check_route_sorting(routes)
+        end
+
+        private
+
+        def rails_routes_draw_block?(node)
+          return false unless node.block_type?
+
+          send_node = node.send_node
+          receiver = send_node.receiver
+          return false unless receiver
+
+          receiver.source == 'Rails.application.routes' && send_node.method_name == :draw
+        end
+
+        def collect_routes(routes_block)
+          collector = RouteCollector.new
+          body = routes_block.body
+          collector.collect(body) if body
+          collector.routes.sort_by { |route| route[:line] }
+        end
+
+        def check_route_sorting(routes)
+          grouped_routes = routes.group_by do |route|
+            [route[:type], route[:namespace_level], route[:namespace_path]]
+          end
+
+          grouped_routes.each_value do |group_routes|
+            next if group_routes.size < 2
+
+            check_group_sorting(group_routes)
+          end
+        end
+
+        def check_group_sorting(group_routes)
+          non_root_routes = group_routes.reject { |route| root_route?(route) }
+          return if non_root_routes.size < 2
+
+          route_names = non_root_routes.map { |route| route[:name] }
+          sorted_names = route_names.sort
+
+          return if route_names == sorted_names
+
+          expected_order = sorted_names.uniq.join(', ')
+          message = format(MSG, expected: expected_order)
+
+          add_offense(non_root_routes.first[:node], message: message)
+        end
+
+        def root_route?(route)
+          route[:name] == 'root'
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      class TimeZoneToday < RuboCop::Cop::Base
+        MSG = 'Do not use Time.zone.today.'
+        RESTRICT_ON_SEND = [:today].freeze
+
+        def_node_matcher :time_zone_today_usage, <<~PATTERN
+          (send
+            (send
+              (const nil? :Time) :zone) :today)
+        PATTERN
+
+        def on_send(node)
+          return unless time_zone_today_usage(node)
+
+          add_offense(node)
+        end
+      end
+    end
+  end
+end