rails_best_practices 1.19.3 → 1.19.4

data/lib/rails_best_practices/core/checks_loader.rb

@@ -20,31 +20,30 @@ module RailsBestPractices
       private
 
         # read the checks from yaml config.
-        def checks_from_config
-          @checks ||= YAML.load_file @config
-        end
+      def checks_from_config
+        @checks ||= YAML.load_file @config
+      end
 
         # load all checks from the configuration
-        def load_checks_from_config(&block)
-          checks_from_config.inject([]) do |active_checks, check|
-            check_instance = instantiate_check(block, *check)
-            active_checks << check_instance unless check_instance.nil?
-            active_checks
-          end
+      def load_checks_from_config(&block)
+        checks_from_config.each_with_object([]) do |check, active_checks|
+          check_instance = instantiate_check(block, *check)
+          active_checks << check_instance unless check_instance.nil?
         end
+      end
 
         # instantiates a check
-        def instantiate_check(block, check_name, options)
-          check_class = load_check_class(check_name, &block)
-          check_class.new(options || {}) unless check_class.nil?
-        end
+      def instantiate_check(block, check_name, options)
+        check_class = load_check_class(check_name, &block)
+        check_class.new(options || {}) unless check_class.nil?
+      end
 
         # loads the class for a check by calling the given block
-        def load_check_class(check_name, &block)
-          block.call(check_name)
-        rescue NameError
-          # nothing to do, the check does not exist
-        end
+      def load_check_class(check_name)
+        yield(check_name)
+      rescue NameError
+        # nothing to do, the check does not exist
+      end
     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
@@ -123,13 +124,13 @@ 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)|
+        @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 { |method| method.used }
+                              methods.select { |method| method.access_control == access_control && !method.used }
+                            else
+                              methods.reject(&:used)
           end
-        }.reject { |method| method.access_control == 'public' && @possible_methods[method.method_name] }
+        end.reject { |method| method.access_control == 'public' && @possible_methods[method.method_name] }
       end
 
       private
@@ -138,9 +139,9 @@ module RailsBestPractices
         #
         # @param [String] class name
         # @return [Array] array of methods
-        def methods(class_name)
-          @methods[class_name] ||= []
-        end
+      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

@@ -39,7 +39,7 @@ module RailsBestPractices
       end
 
       # delegate each to @associations.
-      def each(&block)
+      def each
         @associations.each { |model, model_associations| yield model, model_associations }
       end
 

data/lib/rails_best_practices/core/runner.rb

@@ -123,52 +123,52 @@ module RailsBestPractices
         #
         # @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
+      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
+      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
+      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/option_parser.rb

@@ -0,0 +1,140 @@
+# frozen_string_literal: true
+
+require 'optparse'
+
+module RailsBestPractices
+  class OptionParser
+    # Usage: rails_best_practices [options] path
+    #    -d, --debug                      debug mode
+    #        --silent                     silent mode
+    #    -f, --format FORMAT              output format (text, html, yml, json, xml)
+    #        --output-file FILE           output html file for the analyzing result
+    #        --without-color              only output plain text without color
+    #        --with-textmate              open file by textmate in html format
+    #        --with-sublime               open file by sublime in html format (requires subl-handler)
+    #        --with-mvim                  open file by mvim in html format
+    #        --with-github GITHUB_NAME    open file on github in html format, GITHUB_NAME is like railsbp/rails-bestpractices.com
+    #        --with-git                   display git commit and username, only support html format
+    #        --with-hg                    display hg commit and username, only support html format
+    #        --template TEMPLATE          customize erb template
+    #        --vendor                     include vendor files
+    #        --spec                       include spec files
+    #        --test                       include test files
+    #        --features                   include features files
+    #    -x, --exclude PATTERNS           don't analyze files matching a pattern
+    #                                     (comma-separated regexp list)
+    #    -o, --only PATTERNS              analyze files only matching a pattern
+    #                                     (comma-separated regexp list)
+    #    -g, --generate                   generate configuration yaml
+    #    -v, --version                    show this version
+    #    -h, --help                       show this message
+
+    def self.parse!(argv = ARGV)
+      options = {}
+      OptParse.new do |opts|
+        opts.default_argv = argv
+
+        opts.banner = 'Usage: rails_best_practices [options] path'
+
+        opts.on('-d', '--debug', 'Debug mode') do
+          options['debug'] = true
+        end
+
+        opts.on('-f', '--format FORMAT', 'output format (text, html, yml, json, xml)') do |format|
+          options['format'] = format
+        end
+
+        opts.on('--without-color', 'only output plain text without color') do
+          options['without-color'] = true
+        end
+
+        opts.on('--with-textmate', 'open file by textmate in html format') do
+          options['with-textmate'] = true
+        end
+
+        opts.on('--with-sublime', 'open file by sublime in html format') do
+          options['with-sublime'] = true
+        end
+
+        opts.on('--with-mvim', 'open file by mvim in html format') do
+          options['with-mvim'] = true
+        end
+
+        opts.on('--with-github GITHUB_NAME', 'open file on github in html format') do |github_name|
+          options['with-github'] = true
+          options['github-name'] = github_name
+        end
+
+        opts.on('--last-commit-id COMMIT_ID', 'last commit id') do |commit_id|
+          options['last-commit-id'] = commit_id
+        end
+
+        opts.on('--with-hg', 'display hg commit and username, only support html format') do
+          options['with-hg'] = true
+        end
+
+        opts.on('--with-git', 'display git commit and username, only support html format') do
+          options['with-git'] = true
+        end
+
+        opts.on('--template TEMPLATE', 'customize erb template') do |template|
+          options['template'] = template
+        end
+
+        opts.on('--output-file OUTPUT_FILE', 'output html file for the analyzing result') do |output_file|
+          options['output-file'] = output_file
+        end
+
+        opts.on('--silent', 'silent mode') do
+          options['silent'] = true
+        end
+
+        %w[vendor spec test features].each do |pattern|
+          opts.on("--#{pattern}", "include #{pattern} files") do
+            options[pattern] = true
+          end
+        end
+
+        opts.on_tail('-v', '--version', 'Show this version') do
+          require 'rails_best_practices/version'
+          puts RailsBestPractices::VERSION
+          exit
+        end
+
+        opts.on_tail('-h', '--help', 'Show this message') do
+          puts opts
+          exit
+        end
+
+        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
+            raise OptionParser::InvalidArgument, e.message
+          end
+        end
+
+        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
+          end
+        end
+
+        opts.on('-g', '--generate', 'Generate configuration yaml') do
+          options['generate'] = true
+        end
+
+        opts.on(
+          '-c',
+          '--config CONFIG_PATH', 'configuration file location (defaults to config/rails_best_practices.yml)'
+        ) do |config_path|
+          options['config'] = config_path
+        end
+        opts.parse!
+      end
+      options
+    end
+  end
+end

data/lib/rails_best_practices/prepares/controller_prepare.rb

@@ -25,14 +25,12 @@ module RailsBestPractices
       add_callback :start_class do |_node|
         @controllers << @klass
         @current_controller_name = @klass.to_s
-        if @inherited_resources
-          @actions = DEFAULT_ACTIONS
-        end
+        @actions = DEFAULT_ACTIONS if @inherited_resources
       end
 
       # remember the action names at the end of class node if the controller is a InheritedResources.
       add_callback :end_class do |node|
-        if @inherited_resources && 'ApplicationController' != @current_controller_name
+        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)
           end
@@ -41,27 +39,23 @@ module RailsBestPractices
 
       # check if there is a DSL call inherit_resources.
       add_callback :start_var_ref do |_node|
-        if @inherited_resources
-          @actions = DEFAULT_ACTIONS
-        end
+        @actions = DEFAULT_ACTIONS if @inherited_resources
       end
 
       # check if there is a DSL call inherit_resources.
       add_callback :start_vcall do |_node|
-        if @inherited_resources
-          @actions = DEFAULT_ACTIONS
-        end
+        @actions = DEFAULT_ACTIONS if @inherited_resources
       end
 
       # restrict actions for inherited_resources
       add_callback :start_command do |node|
-        if 'include' == node.message.to_s
+        if node.message.to_s == 'include'
           @helpers.add_module_descendant(node.arguments.all.first.to_s, current_class_name)
-        elsif @inherited_resources && 'actions' ==  node.message.to_s
-          if 'all' == node.arguments.all.first.to_s
+        elsif @inherited_resources && node.message.to_s == 'actions'
+          if node.arguments.all.first.to_s == 'all'
             @actions = DEFAULT_ACTIONS
             option_argument = node.arguments.all[1]
-            if option_argument && :bare_assoc_hash == option_argument.sexp_type && option_argument.hash_value('except')
+            if option_argument && option_argument.sexp_type == :bare_assoc_hash && option_argument.hash_value('except')
               @actions -= option_argument.hash_value('except').to_object
             end
           else

data/lib/rails_best_practices/prepares/gemfile_prepare.rb

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

data/lib/rails_best_practices/prepares/initializer_prepare.rb

@@ -21,9 +21,9 @@ module RailsBestPractices
       # check if the node is
       #     ActiveRecord::Base.send(:include, ActiveModel::ForbiddenAttributesProtection)
       def include_forbidden_attributes_protection?(node)
-        'ActiveRecord::Base' == node.receiver.to_s &&
-          'send' == node.message.to_s &&
-          ['include', 'ActiveModel::ForbiddenAttributesProtection'] == node.arguments.all.map(&:to_s)
+        node.receiver.to_s == 'ActiveRecord::Base' &&
+          node.message.to_s == 'send' &&
+          node.arguments.all.map(&:to_s) == ['include', 'ActiveModel::ForbiddenAttributesProtection']
       end
     end
   end

data/lib/rails_best_practices/prepares/mailer_prepare.rb

@@ -18,7 +18,7 @@ module RailsBestPractices
       # if it is a subclass of ActionMailer::Base,
       # then remember its class name.
       add_callback :start_class do |_node|
-        if 'ActionMailer::Base' == current_extend_class_name
+        if current_extend_class_name == 'ActionMailer::Base'
           @mailers << @klass
         end
       end

data/lib/rails_best_practices/prepares/model_prepare.rb

@@ -21,7 +21,7 @@ module RailsBestPractices
 
       # remember the class name.
       add_callback :start_class do |_node|
-        if 'ActionMailer::Base' != current_extend_class_name
+        if current_extend_class_name != 'ActionMailer::Base'
           @models << @klass
         end
       end
@@ -40,8 +40,8 @@ module RailsBestPractices
       #     }
       add_callback :start_def do |node|
         if @klass &&
-            'ActionMailer::Base' != current_extend_class_name &&
-            (classable_modules.empty? || klasses.any?)
+           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)
         end
@@ -60,7 +60,7 @@ module RailsBestPractices
       #       }
       #     }
       add_callback :start_defs do |node|
-        if @klass && 'ActionMailer::Base' != current_extend_class_name
+        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)
         end
@@ -123,16 +123,16 @@ module RailsBestPractices
       private
 
         # 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
-          arguments_node = node.arguments.all.last
-          if arguments_node.hash_value('class_name').present?
-            association_class = arguments_node.hash_value('class_name').to_s
-          end
-          association_class ||= association_name.classify
-          @model_associations.add_association(current_class_name, association_name, association_meta, association_class)
+      def remember_association(node)
+        association_meta = node.message.to_s
+        association_name = node.arguments.all.first.to_s
+        arguments_node = node.arguments.all.last
+        if arguments_node.hash_value('class_name').present?
+          association_class = arguments_node.hash_value('class_name').to_s
         end
+        association_class ||= association_name.classify
+        @model_associations.add_association(current_class_name, association_name, association_meta, association_class)
+      end
     end
   end
 end