rubocop-nueca 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 4a58e87bfcf5ac18b1e87c51da6a3fd4b37e53c664ec86518ae05c5275b446b2
+  data.tar.gz: 9f08cc06b6f03c0bd16ab76fd3b66e2540f2e4c1ba06d23a02f0bffe49c778fa
+SHA512:
+  metadata.gz: 436c241836f68bd0136f66d6639ea08c2d8e935583609a421c1045222903aff380a4553df6169dd9131e7e6fddeaf82110a003e4050f0966c1955bbcaa8d3d33
+  data.tar.gz: 27fb4e271c37e2ee980669e81f8c0237d3314a3fc77ba0310bc2401c75430b99cbe765991c418b848432c3ff20de036e338c09a86d26370171368bcac46aedae

data/CODE_OF_CONDUCT.md

@@ -0,0 +1,132 @@
+# Contributor Covenant Code of Conduct
+
+## Our Pledge
+
+We as members, contributors, and leaders pledge to make participation in our
+community a harassment-free experience for everyone, regardless of age, body
+size, visible or invisible disability, ethnicity, sex characteristics, gender
+identity and expression, level of experience, education, socio-economic status,
+nationality, personal appearance, race, caste, color, religion, or sexual
+identity and orientation.
+
+We pledge to act and interact in ways that contribute to an open, welcoming,
+diverse, inclusive, and healthy community.
+
+## Our Standards
+
+Examples of behavior that contributes to a positive environment for our
+community include:
+
+* Demonstrating empathy and kindness toward other people
+* Being respectful of differing opinions, viewpoints, and experiences
+* Giving and gracefully accepting constructive feedback
+* Accepting responsibility and apologizing to those affected by our mistakes,
+  and learning from the experience
+* Focusing on what is best not just for us as individuals, but for the overall
+  community
+
+Examples of unacceptable behavior include:
+
+* The use of sexualized language or imagery, and sexual attention or advances of
+  any kind
+* Trolling, insulting or derogatory comments, and personal or political attacks
+* Public or private harassment
+* Publishing others' private information, such as a physical or email address,
+  without their explicit permission
+* Other conduct which could reasonably be considered inappropriate in a
+  professional setting
+
+## Enforcement Responsibilities
+
+Community leaders are responsible for clarifying and enforcing our standards of
+acceptable behavior and will take appropriate and fair corrective action in
+response to any behavior that they deem inappropriate, threatening, offensive,
+or harmful.
+
+Community leaders have the right and responsibility to remove, edit, or reject
+comments, commits, code, wiki edits, issues, and other contributions that are
+not aligned to this Code of Conduct, and will communicate reasons for moderation
+decisions when appropriate.
+
+## Scope
+
+This Code of Conduct applies within all community spaces, and also applies when
+an individual is officially representing the community in public spaces.
+Examples of representing our community include using an official email address,
+posting via an official social media account, or acting as an appointed
+representative at an online or offline event.
+
+## Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be
+reported to the community leaders responsible for enforcement at
+[INSERT CONTACT METHOD].
+All complaints will be reviewed and investigated promptly and fairly.
+
+All community leaders are obligated to respect the privacy and security of the
+reporter of any incident.
+
+## Enforcement Guidelines
+
+Community leaders will follow these Community Impact Guidelines in determining
+the consequences for any action they deem in violation of this Code of Conduct:
+
+### 1. Correction
+
+**Community Impact**: Use of inappropriate language or other behavior deemed
+unprofessional or unwelcome in the community.
+
+**Consequence**: A private, written warning from community leaders, providing
+clarity around the nature of the violation and an explanation of why the
+behavior was inappropriate. A public apology may be requested.
+
+### 2. Warning
+
+**Community Impact**: A violation through a single incident or series of
+actions.
+
+**Consequence**: A warning with consequences for continued behavior. No
+interaction with the people involved, including unsolicited interaction with
+those enforcing the Code of Conduct, for a specified period of time. This
+includes avoiding interactions in community spaces as well as external channels
+like social media. Violating these terms may lead to a temporary or permanent
+ban.
+
+### 3. Temporary Ban
+
+**Community Impact**: A serious violation of community standards, including
+sustained inappropriate behavior.
+
+**Consequence**: A temporary ban from any sort of interaction or public
+communication with the community for a specified period of time. No public or
+private interaction with the people involved, including unsolicited interaction
+with those enforcing the Code of Conduct, is allowed during this period.
+Violating these terms may lead to a permanent ban.
+
+### 4. Permanent Ban
+
+**Community Impact**: Demonstrating a pattern of violation of community
+standards, including sustained inappropriate behavior, harassment of an
+individual, or aggression toward or disparagement of classes of individuals.
+
+**Consequence**: A permanent ban from any sort of public interaction within the
+community.
+
+## Attribution
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage],
+version 2.1, available at
+[https://www.contributor-covenant.org/version/2/1/code_of_conduct.html][v2.1].
+
+Community Impact Guidelines were inspired by
+[Mozilla's code of conduct enforcement ladder][Mozilla CoC].
+
+For answers to common questions about this code of conduct, see the FAQ at
+[https://www.contributor-covenant.org/faq][FAQ]. Translations are available at
+[https://www.contributor-covenant.org/translations][translations].
+
+[homepage]: https://www.contributor-covenant.org
+[v2.1]: https://www.contributor-covenant.org/version/2/1/code_of_conduct.html
+[Mozilla CoC]: https://github.com/mozilla/diversity
+[FAQ]: https://www.contributor-covenant.org/faq
+[translations]: https://www.contributor-covenant.org/translations

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2025 TODO: Write your name
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,26 @@
+# About
+
+This enforces custom rules for Nueca according to culture.
+
+## Installation
+
+Add to your Gemfile the following code.
+
+```ruby
+gem 'rubocop-nueca', require: false
+```
+
+Run `bundle install`.
+
+# Usage
+
+Add to your `.rubocop.yml` the following code.
+
+```yaml
+plugins:
+    - rubocop-nueca
+```
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/config/default.yml

@@ -0,0 +1,106 @@
+plugins:
+  - rubocop-capybara
+  - rubocop-factory_bot
+  - rubocop-performance
+  - rubocop-rails
+  - rubocop-rspec
+  - rubocop-rspec_rails
+
+AllCops:
+  NewCops: enable
+  Exclude:
+    - 'bin/**/*'
+    - 'config/environments/**/*'
+    - 'db/*schema.rb'
+
+Style/SymbolArray:
+  EnforcedStyle: brackets
+
+Style/WordArray:
+  EnforcedStyle: brackets
+
+Metrics/BlockLength:
+  CountComments: false
+  CountAsOne: [array, hash, heredoc, method_call]
+  Exclude:
+    - '**/config/routes.rb'
+    - '**/config/routes/**/*'
+
+Metrics/ClassLength:
+  CountComments: false
+  CountAsOne: [array, hash, heredoc, method_call]
+  Exclude:
+    - 'db/migrate/**/*'
+
+Metrics/MethodLength:
+  Max: 20
+  CountComments: false
+  CountAsOne: [array, hash, heredoc, method_call]
+  Exclude:
+    - 'db/migrate/**/*'
+
+Metrics/ModuleLength:
+  CountComments: false
+  CountAsOne: [array, hash, heredoc, method_call]
+
+Naming/PredicateMethod:
+  AllowedMethods:
+    - call
+    - data
+    - action
+
+Naming/AccessorMethodName:
+  Exclude:
+    - 'app/datatables/**/*'
+
+Lint/MissingSuper:
+  Enabled: false
+
+Style/ClassAndModuleChildren:
+  Enabled: false
+
+Style/HashSyntax:
+  EnforcedShorthandSyntax: never
+
+Metrics/AbcSize:
+  Max: 21
+
+Rails/I18nLocaleTexts:
+  Enabled: false
+
+RSpec/ImplicitSubject:
+  EnforcedStyle: single_statement_only
+
+RSpec/SharedExamples:
+  EnforcedStyle: symbol
+
+RSpec/MultipleMemoizedHelpers:
+  Max: 10
+
+RSpec/NestedGroups:
+  Max: 5
+
+RSpec/VerifiedDoubles:
+  Enabled: false
+
+Rails/HelperInstanceVariable:
+  Enabled: false
+
+RSpec/ExampleLength:
+  Enabled: false
+
+Rails/UnknownEnv:
+  Environments:
+    - production
+    - development
+    - test
+    - staging
+
+RSpec/MultipleExpectations:
+  Enabled: false
+
+Rails/CreateTableWithTimestamps:
+  Enabled: false
+
+Style/Documentation:
+  Enabled: false

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

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      class DateTimeConversion < RuboCop::Cop::Base
+        MSG = 'Use in_time_zone(...) instead of using to_datetime.'
+        RESTRICT_ON_SEND = [:to_datetime].freeze
+
+        def on_send(node)
+          add_offense(node)
+        end
+
+        def on_csend(node)
+          return unless node.method_name == :to_datetime
+
+          add_offense(node)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      class DateTimeCurrent < RuboCop::Cop::Base
+        MSG = 'Use Time.current instead of DateTime.current.'
+        RESTRICT_ON_SEND = [:current].freeze
+
+        def_node_matcher :datetime_curent_usage, <<~PATTERN
+          (send
+            (const nil? :DateTime) :current)
+        PATTERN
+
+        def on_send(node)
+          return unless datetime_curent_usage(node)
+
+          add_offense(node)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      class MigrationTableVariable < RuboCop::Cop::Base
+        MSG = 'Use `t` as the variable name for table operations in migrations.'
+
+        def_node_matcher :create_table_block, <<~PATTERN
+          (block (send nil? :create_table ...) (args (arg $_)) ...)
+        PATTERN
+
+        def_node_matcher :change_table_block, <<~PATTERN
+          (block (send nil? :change_table ...) (args (arg $_)) ...)
+        PATTERN
+
+        def on_block(node)
+          return unless in_migration_file?
+
+          variable_name = extract_table_variable(node)
+          return unless variable_name
+          return if variable_name == :t
+
+          add_offense(node.arguments.first, message: MSG)
+        end
+
+        private
+
+        def extract_table_variable(node)
+          create_table_block(node) ||
+            change_table_block(node)
+        end
+
+        def in_migration_file?
+          processed_source.file_path&.include?('db/migrate/') || false
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      class ModelAssociationConsistentSpacing < RuboCop::Cop::Base
+        MSG = 'Do not leave blank lines between associations of the same type.'
+        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.empty?
+
+          check_consistent_spacing(associations)
+        end
+
+        private
+
+        def model_class?(node)
+          node_parent = node.parent_class
+          return false unless node_parent
+
+          parent_class = node_parent
+          parent_class_name = case parent_class.type
+                              when :const
+                                parent_class.const_name
+                              else
+                                parent_class.source
+                              end
+
+          parent_class_name&.include?('ApplicationRecord') ||
+            parent_class_name&.include?('ActiveRecord::Base')
+        end
+
+        def find_associations(class_node)
+          associations = []
+
+          body = class_node.body
+          body&.each_child_node do |child|
+            next unless child.type == :send
+
+            method_name = child.method_name
+            associations << child if ASSOCIATION_METHODS.include?(method_name)
+          end
+
+          associations
+        end
+
+        def check_consistent_spacing(associations)
+          associations.each_cons(2) do |prev_assoc, curr_assoc|
+            next unless prev_assoc.method_name == curr_assoc.method_name
+
+            prev_end_line = prev_assoc.loc.last_line
+            curr_start_line = curr_assoc.loc.line
+
+            next unless curr_start_line - prev_end_line > 1
+
+            add_offense(curr_assoc, message: MSG)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      class ModelAssociationGrouping < RuboCop::Cop::Base
+        MSG = 'Group associations of the same type together.'
+        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.empty?
+
+          check_association_grouping(associations)
+        end
+
+        private
+
+        def model_class?(node)
+          node_parent = node.parent_class
+          return false unless node_parent
+
+          parent_class = node_parent
+          parent_class_name = case parent_class.type
+                              when :const
+                                parent_class.const_name
+                              else
+                                parent_class.source
+                              end
+
+          parent_class_name&.include?('ApplicationRecord') ||
+            parent_class_name&.include?('ActiveRecord::Base')
+        end
+
+        def find_associations(class_node)
+          associations = []
+
+          body = class_node.body
+          body&.each_child_node do |child|
+            child_type = child.type
+            next unless child_type == :send
+
+            method_name = child.method_name
+            associations << child if ASSOCIATION_METHODS.include?(method_name)
+          end
+
+          associations
+        end
+
+        def check_association_grouping(associations)
+          grouped_associations = associations.group_by(&:method_name)
+
+          grouped_associations.each_value do |same_type_associations|
+            next if same_type_associations.length <= 1
+
+            check_same_type_grouping(same_type_associations, associations)
+          end
+        end
+
+        def check_same_type_grouping(same_type_associations, all_associations)
+          groups = find_contiguous_groups(same_type_associations, all_associations)
+
+          return unless groups.length > 1
+
+          groups[1..].each do |group|
+            add_offense(group.first, message: MSG)
+          end
+        end
+
+        def find_contiguous_groups(same_type_associations, all_associations)
+          return [] if same_type_associations.empty?
+
+          target_method = same_type_associations.first.method_name
+          sorted_associations = all_associations.sort_by { |assoc| assoc.loc.line }
+
+          build_contiguous_groups(sorted_associations, target_method)
+        end
+
+        def build_contiguous_groups(sorted_associations, target_method)
+          groups = []
+          current_group = []
+
+          (sorted_associations + [nil]).each do |association|
+            if association && matches_target_method?(association, target_method)
+              current_group << association
+            else
+              finalize_group(groups, current_group)
+            end
+          end
+
+          groups
+        end
+
+        def finalize_group(groups, current_group)
+          return unless current_group.any?
+
+          groups << current_group.dup
+          current_group.clear
+        end
+
+        def matches_target_method?(association, target_method)
+          association.method_name == target_method
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      class ModelAssociationScattering < RuboCop::Cop::Base
+        MSG = 'Group all associations together without non-association code scattered between them.'
+        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.empty?
+
+          check_association_scattering(associations, node)
+        end
+
+        private
+
+        def model_class?(node)
+          node_parent = node.parent_class
+          return false unless node_parent
+
+          parent_class = node_parent
+          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 << child
+          end
+
+          associations.sort_by { |assoc| assoc.loc.line }
+        end
+
+        def association_method?(node)
+          return false unless node.receiver.nil?
+
+          ASSOCIATION_METHODS.include?(node.method_name)
+        end
+
+        def check_association_scattering(associations, class_node)
+          scattered_associations = find_scattered_associations(associations, class_node)
+
+          scattered_associations.each do |association|
+            add_offense(association, message: MSG)
+          end
+        end
+
+        def find_scattered_associations(associations, class_node)
+          return [] if associations.size <= 1
+
+          scattered = []
+          body_node = class_node.body
+
+          associations.each_with_index do |assoc, index|
+            next if index.zero?
+
+            current_line = assoc.loc.line
+            prev_assoc = associations[index - 1]
+            prev_line = prev_assoc.loc.line
+
+            if non_association_between?(body_node, prev_line, current_line) && !scattered.include?(assoc) # rubocop:disable Rails/NegateInclude
+              scattered << assoc
+            end
+          end
+
+          scattered
+        end
+
+        def non_association_between?(body_node, start_line, end_line)
+          body_node&.each_child_node do |child|
+            child_line = child.loc.line
+            return true if child_line > start_line && child_line < end_line && !association_node?(child)
+          end
+          false
+        end
+
+        def association_node?(node)
+          node.type == :send && ASSOCIATION_METHODS.include?(node.method_name)
+        end
+      end
+    end
+  end
+end