rails_best_practices 1.19.3 → 1.21.0

data/lib/rails_best_practices/core/controllers.rb

@@ -5,7 +5,6 @@ require_rel 'klasses'
 module RailsBestPractices
   module Core
     # Controller classes.
-    class Controllers < Klasses
-    end
+    class Controllers < Klasses; end
   end
 end

data/lib/rails_best_practices/core/error.rb

@@ -20,7 +20,7 @@ module RailsBestPractices
       end
 
       def short_filename
-        File.expand_path(filename)[File.expand_path(Core::Runner.base_path).size..-1].sub(/^\//, '')
+        File.expand_path(filename)[File.expand_path(Core::Runner.base_path).size..-1].sub(%r{^/}, '')
       end
 
       def first_line_number

data/lib/rails_best_practices/core/helpers.rb

@@ -5,7 +5,6 @@ require_rel 'modules'
 module RailsBestPractices
   module Core
     # Helper moduels.
-    class Helpers < Modules
-    end
+    class Helpers < Modules; end
   end
 end

data/lib/rails_best_practices/core/mailers.rb

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

data/lib/rails_best_practices/core/methods.rb

@@ -18,6 +18,7 @@ module RailsBestPractices
       def add_method(class_name, method_name, meta = {}, access_control = 'public')
         return if class_name == ''
         return if has_method?(class_name, method_name)
+
         methods(class_name) << Method.new(class_name, method_name, access_control, meta)
         if access_control == 'public'
           @possible_methods[method_name] = false
@@ -45,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
@@ -57,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
 
@@ -72,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
 
@@ -82,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.
@@ -91,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
@@ -112,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
@@ -123,24 +128,25 @@ module RailsBestPractices
       # @param [String] access control
       # @return [Array] array of Method
       def get_all_unused_methods(access_control = nil)
-        @methods.inject([]) { |unused_methods, (_class_name, methods)|
-          unused_methods += if access_control
-            methods.select { |method| method.access_control == access_control && !method.used }
-          else
-            methods.reject { |method| method.used }
-          end
-        }.reject { |method| method.access_control == 'public' && @possible_methods[method.method_name] }
+        @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
+        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
-        def methods(class_name)
-          @methods[class_name] ||= []
-        end
+      # Methods of a class.
+      #
+      # @param [String] class name
+      # @return [Array] array of methods
+      def methods(class_name)
+        @methods[class_name] ||= []
+      end
     end
 
     # Method info includes class name, method name, access control, file, line_number, used.

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.
@@ -39,7 +41,7 @@ module RailsBestPractices
       end
 
       # delegate each to @associations.
-      def each(&block)
+      def each
         @associations.each { |model, model_associations| yield model, model_associations }
       end
 
@@ -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,65 +109,81 @@ 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.
-        def parse_html_template(filename, content)
-          if filename =~ /.*\.erb$|.*\.rhtml$/
-            content = Erubis::OnlyRuby.new(content).src
-          elsif filename =~ /.*\.haml$/
-            begin
-              require 'haml'
-              content = Haml::Engine.new(content).precompiled
-              # remove \xxx characters
-              content.gsub!(/\\\d{3}/, '')
-            rescue LoadError
-              raise "In order to parse #{filename}, please install the haml gem"
-            rescue Haml::Error, SyntaxError
-              # do nothing, just ignore the wrong haml files.
-            end
-          elsif filename =~ /.*\.slim$/
-            begin
-              require 'slim'
-              content = Slim::Engine.new.call(content)
-            rescue LoadError
-              raise "In order to parse #{filename}, please install the slim gem"
-            rescue SyntaxError
-              # do nothing, just ignore the wrong slim files
-            end
+      # 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
+        elsif filename =~ /.*\.haml$/
+          begin
+            require 'haml'
+            content = Haml::Engine.new(content).precompiled
+            # remove \xxx characters
+            content.gsub!(/\\\d{3}/, '')
+          rescue LoadError
+            raise "In order to parse #{filename}, please install the haml gem"
+          rescue Haml::Error, SyntaxError
+            # do nothing, just ignore the wrong haml files.
+          end
+        elsif filename =~ /.*\.slim$/
+          begin
+            require 'slim'
+            content = Slim::Engine.new.call(content)
+          rescue LoadError
+            raise "In order to parse #{filename}, please install the slim gem"
+          rescue SyntaxError
+            # do nothing, just ignore the wrong slim files
           end
-          content
         end
+        content
+      end
 
-        # load all prepares.
-        def load_prepares
-          Prepares.constants.map { |prepare| Prepares.const_get(prepare).new }
-        end
+      # load all prepares.
+      def load_prepares
+        Prepares.constants.map { |prepare| Prepares.const_get(prepare).new }
+      end
 
-        # load all plugin reviews.
-        def load_plugin_reviews
-            plugins = File.join(Runner.base_path, 'lib', 'rails_best_practices', 'plugins', 'reviews')
-            if File.directory?(plugins)
-              Dir[File.expand_path(File.join(plugins, '*.rb'))].each do |review|
-                require review
-              end
-              if RailsBestPractices.constants.map(&:to_sym).include? :Plugins
-                RailsBestPractices::Plugins::Reviews.constants.each do |review|
-                  @reviews << RailsBestPractices::Plugins::Reviews.const_get(review).new
-                end
-              end
+      # load all plugin reviews.
+      def load_plugin_reviews
+        plugins = File.join(Runner.base_path, 'lib', 'rails_best_practices', 'plugins', 'reviews')
+        if File.directory?(plugins)
+          Dir[File.expand_path(File.join(plugins, '*.rb'))].each do |review|
+            require review
+          end
+          if RailsBestPractices.constants.map(&:to_sym).include? :Plugins
+            RailsBestPractices::Plugins::Reviews.constants.each do |review|
+              @reviews << RailsBestPractices::Plugins::Reviews.const_get(review).new
             end
+          end
         end
+      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/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