rails_best_practices 1.20.0 → 1.22.1

data/lib/rails_best_practices/core/methods.rb

@@ -46,7 +46,9 @@ module RailsBestPractices
       # @return [Boolean] has a method or not
       def has_method?(class_name, method_name, access_control = nil)
         if access_control
-          !!methods(class_name).find { |method| method.method_name == method_name && method.access_control == access_control }
+          !!methods(class_name).find do |method|
+            method.method_name == method_name && method.access_control == access_control
+          end
         else
           !!methods(class_name).find { |method| method.method_name == method_name }
         end
@@ -58,10 +60,10 @@ module RailsBestPractices
       # @param [String] method name
       def mark_parent_class_method_used(class_name, method_name)
         klass = Prepares.klasses.find { |klass| klass.to_s == class_name }
-        if klass && klass.extend_class_name
+        if klass&.extend_class_name
           mark_parent_class_method_used(klass.extend_class_name, method_name)
           method = get_method(klass.extend_class_name, method_name)
-          method.mark_used if method
+          method&.mark_used
         end
       end
 
@@ -73,7 +75,7 @@ module RailsBestPractices
         Prepares.klasses.select { |klass| klass.extend_class_name == class_name }.each do |klass|
           mark_subclasses_method_used(klass.to_s, method_name)
           method = get_method(klass.to_s, method_name)
-          method.mark_used if method
+          method&.mark_used
         end
       end
 
@@ -83,7 +85,7 @@ module RailsBestPractices
       # @param [String] method name
       def mark_publicize(class_name, method_name)
         method = get_method(class_name, method_name)
-        method.publicize if method
+        method&.publicize
       end
 
       # Mark parent classs' method as public.
@@ -92,7 +94,7 @@ module RailsBestPractices
       # @param [String] method name
       def mark_parent_class_methods_publicize(class_name, method_name)
         klass = Prepares.klasses.find { |klass| klass.to_s == class_name }
-        if klass && klass.extend_class_name
+        if klass&.extend_class_name
           mark_parent_class_methods_publicize(klass.extend_class_name, method_name)
           mark_publicize(class_name, method_name)
         end
@@ -113,7 +115,9 @@ module RailsBestPractices
       # @return [Method] Method object
       def get_method(class_name, method_name, access_control = nil)
         if access_control
-          methods(class_name).find { |method| method.method_name == method_name && method.access_control == access_control }
+          methods(class_name).find do |method|
+            method.method_name == method_name && method.access_control == access_control
+          end
         else
           methods(class_name).find { |method| method.method_name == method_name }
         end
@@ -125,20 +129,21 @@ module RailsBestPractices
       # @return [Array] array of Method
       def get_all_unused_methods(access_control = nil)
         @methods.inject([]) do |unused_methods, (_class_name, methods)|
-          unused_methods += if access_control
-                              methods.select { |method| method.access_control == access_control && !method.used }
-                            else
-                              methods.reject(&:used)
-          end
+          unused_methods +=
+            if access_control
+              methods.select { |method| method.access_control == access_control && !method.used }
+            else
+              methods.reject(&:used)
+            end
         end.reject { |method| method.access_control == 'public' && @possible_methods[method.method_name] }
       end
 
       private
 
-        # Methods of a class.
-        #
-        # @param [String] class name
-        # @return [Array] array of methods
+      # Methods of a class.
+      #
+      # @param [String] class name
+      # @return [Array] array of methods
       def methods(class_name)
         @methods[class_name] ||= []
       end

data/lib/rails_best_practices/core/model_associations.rb

@@ -15,7 +15,9 @@ module RailsBestPractices
       # @param [String] association class name
       def add_association(model_name, association_name, association_meta, association_class = nil)
         @associations[model_name] ||= {}
-        @associations[model_name][association_name] = { 'meta' => association_meta, 'class_name' => association_class || association_name.classify }
+        @associations[model_name][association_name] = {
+          'meta' => association_meta, 'class_name' => association_class || association_name.classify
+        }
       end
 
       # Get a model association.
@@ -25,7 +27,7 @@ module RailsBestPractices
       # @return [Hash] {"meta" => association_meta, "class_name" => association_class}
       def get_association(model_name, association_name)
         associations = @associations[model_name]
-        associations and associations[association_name]
+        associations && associations[association_name]
       end
 
       # If it is a model's association.
@@ -49,8 +51,11 @@ module RailsBestPractices
       # @param [String] association_name
       # @return [String] association's class name
       def get_association_class_name(table_name, association_name)
-        associations = @associations.select { |model, _model_associations| model.gsub('::', '').tableize == table_name }.values.first and
-          association_meta = associations.select { |name, _meta| name == association_name }.values.first and
+        (
+          associations =
+            @associations.select { |model, _model_associations| model.gsub('::', '').tableize == table_name }.values
+              .first
+        ) && (association_meta = associations.select { |name, _meta| name == association_name }.values.first) &&
           association_meta['class_name']
       end
     end

data/lib/rails_best_practices/core/models.rb

@@ -3,7 +3,6 @@
 module RailsBestPractices
   module Core
     # Model classes.
-    class Models < Klasses
-    end
+    class Models < Klasses; end
   end
 end

data/lib/rails_best_practices/core/modules.rb

@@ -10,7 +10,7 @@ module RailsBestPractices
       # @param [String] descendant name
       def add_module_descendant(module_name, descendant)
         mod = find { |mod| mod.to_s == module_name }
-        mod.add_descendant(descendant) if mod
+        mod&.add_descendant(descendant)
       end
     end
 

data/lib/rails_best_practices/core/routes.rb

@@ -24,8 +24,8 @@ module RailsBestPractices
         # mappings can be specified by e.g.
         #   post 'some/:pattern' => 'controller#action'
         if action_name.is_a?(String) && action_name =~ /\A(\w+)#(\w+)\z/
-          controller_name = $1
-          action_name = $2
+          controller_name = Regexp.last_match(1)
+          action_name = Regexp.last_match(2)
         end
 
         if controller_name

data/lib/rails_best_practices/core/runner.rb

@@ -20,33 +20,23 @@ module RailsBestPractices
     class Runner
       attr_reader :checks
 
-      # set the base path.
-      #
-      # @param [String] path the base path
-      def self.base_path=(path)
-        @base_path = path
-      end
-
-      # get the base path, by default, the base path is current path.
-      #
-      # @return [String] the base path
-      def self.base_path
-        @base_path || '.'
-      end
+      class << self
+        attr_writer :base_path, :config_path
 
-      # set the configuration path
-      #
-      # @param path [String] path to rbc config file
-      def self.config_path=(path)
-        @config_path = path
-      end
+        # get the base path, by default, the base path is current path.
+        #
+        # @return [String] the base path
+        def base_path
+          @base_path || '.'
+        end
 
-      # get the configuration path, if will default to config/rails_best_practices.yml
-      #
-      # @return [String] the config path
-      def self.config_path
-        custom_config = @config_path || File.join(Runner.base_path, 'config/rails_best_practices.yml')
-        File.exist?(custom_config) ? custom_config : RailsBestPractices::Analyzer::DEFAULT_CONFIG
+        # get the configuration path, if will default to config/rails_best_practices.yml
+        #
+        # @return [String] the config path
+        def config_path
+          custom_config = @config_path || File.join(Runner.base_path, 'config/rails_best_practices.yml')
+          File.exist?(custom_config) ? custom_config : RailsBestPractices::Analyzer::DEFAULT_CONFIG
+        end
       end
 
       # initialize the runner.
@@ -66,9 +56,18 @@ module RailsBestPractices
         load_plugin_reviews if reviews.empty?
 
         @lexical_checker ||= CodeAnalyzer::CheckingVisitor::Plain.new(checkers: @lexicals)
-        @plain_prepare_checker ||= CodeAnalyzer::CheckingVisitor::Plain.new(checkers: @prepares.select { |checker| checker.is_a? Prepares::GemfilePrepare })
-        @default_prepare_checker ||= CodeAnalyzer::CheckingVisitor::Default.new(checkers: @prepares.reject { |checker| checker.is_a? Prepares::GemfilePrepare })
+        @plain_prepare_checker ||=
+          CodeAnalyzer::CheckingVisitor::Plain.new(
+            checkers: @prepares.select { |checker| checker.is_a? Prepares::GemfilePrepare }
+          )
+        @default_prepare_checker ||=
+          CodeAnalyzer::CheckingVisitor::Default.new(
+            checkers: @prepares.reject { |checker| checker.is_a? Prepares::GemfilePrepare }
+          )
         @review_checker ||= CodeAnalyzer::CheckingVisitor::Default.new(checkers: @reviews)
+
+        @inlnie_disable ||= InlineDisables::InlineDisable.new
+        @inline_disable_checker ||= CodeAnalyzer::CheckingVisitor::Plain.new(checkers: [@inlnie_disable])
       end
 
       # lexical analysis the file.
@@ -110,19 +109,35 @@ module RailsBestPractices
         @review_checker.after_check
       end
 
+      # disable check by inline comment the file.
+      #
+      # @param [String] filename of the file
+      # @param [String] content of the file
+      def inline_disable(filename, content)
+        content = parse_html_template(filename, content)
+        @inline_disable_checker.check(filename, content)
+      end
+
+      def after_inline_disable
+        @inline_disable_checker.after_check
+      end
+
       # get all errors from lexicals and reviews.
       #
       # @return [Array] all errors from lexicals and reviews
       def errors
-        @errors ||= (@reviews + @lexicals).collect(&:errors).flatten
+        @errors ||= begin
+          reported_errors = (@reviews + @lexicals).collect(&:errors).flatten
+          reported_errors.reject { |error| @inlnie_disable.disabled?(error) }
+        end
       end
 
       private
 
-        # parse html template code, erb, haml and slim.
-        #
-        # @param [String] filename is the filename of the erb, haml or slim code.
-        # @param [String] content is the source code of erb, haml or slim file.
+      # parse html template code, erb, haml and slim.
+      #
+      # @param [String] filename is the filename of the erb, haml or slim code.
+      # @param [String] content is the source code of erb, haml or slim file.
       def parse_html_template(filename, content)
         if filename =~ /.*\.erb$|.*\.rhtml$/
           content = Erubis::OnlyRuby.new(content).src
@@ -150,12 +165,12 @@ module RailsBestPractices
         content
       end
 
-        # load all prepares.
+      # load all prepares.
       def load_prepares
         Prepares.constants.map { |prepare| Prepares.const_get(prepare).new }
       end
 
-        # load all plugin reviews.
+      # load all plugin reviews.
       def load_plugin_reviews
         plugins = File.join(Runner.base_path, 'lib', 'rails_best_practices', 'plugins', 'reviews')
         if File.directory?(plugins)

data/lib/rails_best_practices/inline_disables/comment_ripper.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module RailsBestPractices
+  module InlineDisables
+    class CommentRipper < Ripper::SexpBuilder
+      attr_reader :comments
+
+      def initialize(*arg)
+        super
+        @comments = []
+      end
+
+      def on_comment(*arg)
+        # [sexp_type, statement, [lineno, column]] = super
+        comments << super
+      end
+    end
+  end
+end

data/lib/rails_best_practices/inline_disables/inline_disable.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module RailsBestPractices
+  module InlineDisables
+    class InlineDisable < Core::Check
+      interesting_files ALL_FILES
+      url '#'
+
+      def initialize(*args)
+        super
+        @disabled_errors = []
+      end
+
+      def check(filename, content)
+        comments = CommentRipper.new(content).tap(&:parse).comments
+        comments.each do |_sexp_type, statement, (line_number, _column)|
+          add_as_disable_errors(filename, statement, line_number)
+        end
+      end
+
+      def disabled?(error)
+        error_key = [error.filename, error.line_number, error.type.split('::').last].join('-')
+        disabled_error_keys.include?(error_key)
+      end
+
+      private
+
+      def disabled_error_keys
+        @disabled_error_keys ||= Set.new(@disabled_errors.map { |e| [e.filename, e.line_number, e.type].join('-') })
+      end
+
+      def add_as_disable_errors(filename, statement, line_number)
+        match = statement.match(/rails_b(?:est_)?p(?:ractices)?:disable (.*)/)
+        return unless match
+
+        check_names = match[1].split(',')
+        check_names.each do |check_name|
+          add_as_disable_error(filename, check_name.gsub(/Check$/, 'Review'), line_number)
+        end
+      end
+
+      def add_as_disable_error(filename, check_name, line_number)
+        @disabled_errors <<
+          RailsBestPractices::Core::Error.new(
+            filename: filename, line_number: line_number, message: 'disable by inline comment', type: check_name, url: url
+          )
+      end
+    end
+  end
+end

data/lib/rails_best_practices/inline_disables.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require_rel 'inline_disables'

data/lib/rails_best_practices/lexicals/long_line_check.rb

@@ -22,9 +22,13 @@ module RailsBestPractices
           content.each_line do |line|
             line_no += 1
             actual_line_length = line.sub(/\s+$/, '').length
-            if actual_line_length > @max_line_length
-              add_error("line is longer than #{@max_line_length} characters (#{actual_line_length} characters)", filename, line_no)
-            end
+            next unless actual_line_length > @max_line_length
+
+            add_error(
+              "line is longer than #{@max_line_length} characters (#{actual_line_length} characters)",
+              filename,
+              line_no
+            )
           end
         end
       end

data/lib/rails_best_practices/option_parser.rb

@@ -7,9 +7,10 @@ module RailsBestPractices
     # Usage: rails_best_practices [options] path
     #    -d, --debug                      debug mode
     #        --silent                     silent mode
-    #    -f, --format FORMAT              output format (text, html, yml, json, xml)
+    #    -f, --format FORMAT              output format (text, html, yaml, json, xml)
     #        --output-file FILE           output html file for the analyzing result
     #        --without-color              only output plain text without color
+    #        --with-atom                  open file by atom in html format
     #        --with-textmate              open file by textmate in html format
     #        --with-vscode                open file by vscode in html format
     #        --with-sublime               open file by sublime in html format (requires subl-handler)
@@ -41,7 +42,7 @@ module RailsBestPractices
           options['debug'] = true
         end
 
-        opts.on('-f', '--format FORMAT', 'output format (text, html, yml, json, xml)') do |format|
+        opts.on('-f', '--format FORMAT', 'output format (text, html, yaml, json, xml)') do |format|
           options['format'] = format
         end
 
@@ -49,6 +50,10 @@ module RailsBestPractices
           options['without-color'] = true
         end
 
+        opts.on('--with-atom', 'open file by atom in html format') do
+          options['with-atom'] = true
+        end
+
         opts.on('--with-textmate', 'open file by textmate in html format') do
           options['with-textmate'] = true
         end
@@ -111,7 +116,12 @@ module RailsBestPractices
           exit
         end
 
-        opts.on('-x', '--exclude PATTERNS', "Don't analyze files matching a pattern", '(comma-separated regexp list)') do |list|
+        opts.on(
+          '-x',
+          '--exclude PATTERNS',
+          "Don't analyze files matching a pattern",
+          '(comma-separated regexp list)'
+        ) do |list|
           begin
             options['exclude'] = list.split(',').map { |x| Regexp.new x }
           rescue RegexpError => e
@@ -119,11 +129,16 @@ module RailsBestPractices
           end
         end
 
-        opts.on('-o', '--only PATTERNS', 'Analyze files only matching a pattern', '(comma-separated regexp list)') do |list|
+        opts.on(
+          '-o',
+          '--only PATTERNS',
+          'Analyze files only matching a pattern',
+          '(comma-separated regexp list)'
+        ) do |list|
           begin
             options['only'] = list.split(',').map { |x| Regexp.new x }
           rescue RegexpError => e
-            raise OptionParser::InvalidArgument e.message
+            raise OptionParser::InvalidArgument, e.message
           end
         end
 
@@ -133,7 +148,8 @@ module RailsBestPractices
 
         opts.on(
           '-c',
-          '--config CONFIG_PATH', 'configuration file location (defaults to config/rails_best_practices.yml)'
+          '--config CONFIG_PATH',
+          'configuration file location (defaults to config/rails_best_practices.yml)'
         ) do |config_path|
           options['config'] = config_path
         end

data/lib/rails_best_practices/prepares/controller_prepare.rb

@@ -3,6 +3,7 @@
 module RailsBestPractices
   module Prepares
     # Remember controllers and controller methods
+
     class ControllerPrepare < Core::Check
       include Core::Check::Classable
       include Core::Check::InheritedResourcesable
@@ -32,7 +33,11 @@ module RailsBestPractices
       add_callback :end_class do |node|
         if @inherited_resources && @current_controller_name != 'ApplicationController'
           @actions.each do |action|
-            @methods.add_method(@current_controller_name, action, 'file' => node.file, 'line_number' => node.line_number)
+            @methods.add_method(
+              @current_controller_name,
+              action,
+              'file' => node.file, 'line_number' => node.line_number
+            )
           end
         end
       end
@@ -78,14 +83,21 @@ module RailsBestPractices
       #     }
       add_callback :start_def do |node|
         method_name = node.method_name.to_s
-        @methods.add_method(current_class_name, method_name, { 'file' => node.file, 'line_number' => node.line_number }, current_access_control)
+        @methods.add_method(
+          current_class_name,
+          method_name,
+          { 'file' => node.file, 'line_number' => node.line_number },
+          current_access_control
+        )
       end
 
       # ask Reviews::RemoveUnusedMoethodsInHelperReview to check the controllers who include helpers.
       add_callback :after_check do
         descendants = @helpers.map(&:descendants).flatten
         if descendants.present?
-          Reviews::RemoveUnusedMethodsInHelpersReview.interesting_files *descendants.map { |descendant| /#{descendant.underscore}/ }
+          Reviews::RemoveUnusedMethodsInHelpersReview.interesting_files *descendants.map { |descendant|
+                                                                          /#{descendant.underscore}/
+                                                                        }
         end
       end
     end

data/lib/rails_best_practices/prepares/gemfile_prepare.rb

@@ -13,7 +13,7 @@ module RailsBestPractices
       def check(_filename, content)
         content.split("\n").each do |line|
           if line =~ /([^ ]+) \((\d.*)\)/
-            @gems << Core::Gem.new($1, $2)
+            @gems << Core::Gem.new(Regexp.last_match(1), Regexp.last_match(2))
           end
         end
       end

data/lib/rails_best_practices/prepares/helper_prepare.rb

@@ -32,7 +32,12 @@ module RailsBestPractices
       add_callback :start_def do |node|
         if node.file =~ HELPER_FILES
           method_name = node.method_name.to_s
-          @methods.add_method(current_module_name, method_name, { 'file' => node.file, 'line_number' => node.line_number }, current_access_control)
+          @methods.add_method(
+            current_module_name,
+            method_name,
+            { 'file' => node.file, 'line_number' => node.line_number },
+            current_access_control
+          )
         end
       end
     end

data/lib/rails_best_practices/prepares/initializer_prepare.rb

@@ -3,6 +3,7 @@
 module RailsBestPractices
   module Prepares
     # Check all initializers
+
     class InitializerPrepare < Core::Check
       interesting_nodes :method_add_arg, :class
       interesting_files INITIALIZER_FILES
@@ -21,8 +22,7 @@ module RailsBestPractices
       # check if the node is
       #     ActiveRecord::Base.send(:include, ActiveModel::ForbiddenAttributesProtection)
       def include_forbidden_attributes_protection?(node)
-        node.receiver.to_s == 'ActiveRecord::Base' &&
-          node.message.to_s == 'send' &&
+        node.receiver.to_s == 'ActiveRecord::Base' && node.message.to_s == 'send' &&
           node.arguments.all.map(&:to_s) == ['include', 'ActiveModel::ForbiddenAttributesProtection']
       end
     end

data/lib/rails_best_practices/prepares/mailer_prepare.rb

@@ -3,6 +3,7 @@
 module RailsBestPractices
   module Prepares
     # Remember the mailer names.
+
     class MailerPrepare < Core::Check
       include Core::Check::Classable
 

data/lib/rails_best_practices/prepares/model_prepare.rb

@@ -3,6 +3,7 @@
 module RailsBestPractices
   module Prepares
     # Remember models and model associations.
+
     class ModelPrepare < Core::Check
       include Core::Check::Classable
       include Core::Check::Accessable
@@ -10,7 +11,17 @@ module RailsBestPractices
       interesting_nodes :class, :def, :defs, :command, :alias
       interesting_files MODEL_FILES
 
-      ASSOCIATION_METHODS = %w[belongs_to has_one has_many has_and_belongs_to_many embeds_many embeds_one embedded_in many one].freeze
+      ASSOCIATION_METHODS = %w[
+        belongs_to
+        has_one
+        has_many
+        has_and_belongs_to_many
+        embeds_many
+        embeds_one
+        embedded_in
+        many
+        one
+      ].freeze
 
       def initialize
         @models = Prepares.models
@@ -39,11 +50,14 @@ module RailsBestPractices
       #       }
       #     }
       add_callback :start_def do |node|
-        if @klass &&
-           current_extend_class_name != 'ActionMailer::Base' &&
-           (classable_modules.empty? || klasses.any?)
+        if @klass && current_extend_class_name != 'ActionMailer::Base' && (classable_modules.empty? || klasses.any?)
           method_name = node.method_name.to_s
-          @methods.add_method(current_class_name, method_name, { 'file' => node.file, 'line_number' => node.line_number }, current_access_control)
+          @methods.add_method(
+            current_class_name,
+            method_name,
+            { 'file' => node.file, 'line_number' => node.line_number },
+            current_access_control
+          )
         end
       end
 
@@ -62,7 +76,12 @@ module RailsBestPractices
       add_callback :start_defs do |node|
         if @klass && current_extend_class_name != 'ActionMailer::Base'
           method_name = node.method_name.to_s
-          @methods.add_method(current_class_name, method_name, { 'file' => node.file, 'line_number' => node.line_number }, current_access_control)
+          @methods.add_method(
+            current_class_name,
+            method_name,
+            { 'file' => node.file, 'line_number' => node.line_number },
+            current_access_control
+          )
         end
       end
 
@@ -81,15 +100,31 @@ module RailsBestPractices
         case node.message.to_s
         when 'named_scope', 'scope', 'alias_method'
           method_name = node.arguments.all.first.to_s
-          @methods.add_method(current_class_name, method_name, { 'file' => node.file, 'line_number' => node.line_number }, current_access_control)
+          @methods.add_method(
+            current_class_name,
+            method_name,
+            { 'file' => node.file, 'line_number' => node.line_number },
+            current_access_control
+          )
         when 'alias_method_chain'
           method, feature = *node.arguments.all.map(&:to_s)
-          @methods.add_method(current_class_name, "#{method}_with_#{feature}", { 'file' => node.file, 'line_number' => node.line_number }, current_access_control)
-          @methods.add_method(current_class_name, method.to_s, { 'file' => node.file, 'line_number' => node.line_number }, current_access_control)
+          @methods.add_method(
+            current_class_name,
+            "#{method}_with_#{feature}",
+            { 'file' => node.file, 'line_number' => node.line_number },
+            current_access_control
+          )
+          @methods.add_method(
+            current_class_name,
+            method.to_s,
+            { 'file' => node.file, 'line_number' => node.line_number },
+            current_access_control
+          )
         when 'field'
           arguments = node.arguments.all
           attribute_name = arguments.first.to_s
-          attribute_type = arguments.last.hash_value('type').present? ? arguments.last.hash_value('type').to_s : 'String'
+          attribute_type =
+            arguments.last.hash_value('type').present? ? arguments.last.hash_value('type').to_s : 'String'
           @model_attributes.add_attribute(current_class_name, attribute_name, attribute_type)
         when 'key'
           attribute_name, attribute_type = node.arguments.all.map(&:to_s)
@@ -102,7 +137,12 @@ module RailsBestPractices
       # check alias node to remembr the alias methods.
       add_callback :start_alias do |node|
         method_name = node.new_method.to_s
-        @methods.add_method(current_class_name, method_name, { 'file' => node.file, 'line_number' => node.line_number }, current_access_control)
+        @methods.add_method(
+          current_class_name,
+          method_name,
+          { 'file' => node.file, 'line_number' => node.line_number },
+          current_access_control
+        )
       end
 
       # after prepare process, fix incorrect associations' class_name.
@@ -122,7 +162,7 @@ module RailsBestPractices
 
       private
 
-        # remember associations, with class to association names.
+      # remember associations, with class to association names.
       def remember_association(node)
         association_meta = node.message.to_s
         association_name = node.arguments.all.first.to_s