rails_best_practices 1.19.3 → 1.19.4

data/lib/rails_best_practices/reviews/use_parentheses_in_method_def_review.rb

@@ -21,13 +21,13 @@ module RailsBestPractices
 
       protected
 
-        def no_parentheses_around_parameters?(def_node)
-          :parent != def_node[2][0]
-        end
+      def no_parentheses_around_parameters?(def_node)
+        def_node[2][0] != :parent
+      end
 
-        def has_parameters?(def_node)
-          :params == def_node[2][0] && !def_node[2][1..-1].compact.empty?
-        end
+      def has_parameters?(def_node)
+        def_node[2][0] == :params && !def_node[2][1..-1].compact.empty?
+      end
     end
   end
 end

data/lib/rails_best_practices/reviews/use_query_attribute_review.rb

@@ -35,12 +35,13 @@ module RailsBestPractices
       # then the call node can use query attribute instead.
       add_callback :start_if, :start_unless, :start_elsif, :start_ifop, :start_if_mod, :start_unless_mod do |node|
         all_conditions = if node.conditional_statement == node.conditional_statement.all_conditions
-          [node.conditional_statement]
-        else
-          node.conditional_statement.all_conditions
+                           [node.conditional_statement]
+                         else
+                           node.conditional_statement.all_conditions
         end
         all_conditions.each do |condition_node|
           next unless query_attribute_node = query_attribute_node(condition_node)
+
           receiver_node = query_attribute_node.receiver
           add_error "use query attribute (#{receiver_node.receiver}.#{receiver_node.message}?)",
                     node.file,
@@ -52,23 +53,23 @@ module RailsBestPractices
 
         # recursively check conditional statement nodes to see if there is a call node that may be
         # possible query attribute.
-        def query_attribute_node(conditional_statement_node)
-          case conditional_statement_node.sexp_type
-          when :and, :or
-            node = query_attribute_node(conditional_statement_node[1]) ||
-              query_attribute_node(conditional_statement_node[2])
-            node.file = conditional_statement_code.file
-            return node
-          when :not
-            node = query_attribute_node(conditional_statement_node[1])
-            node.file = conditional_statement_node.file
-          when :call
-            return conditional_statement_node if possible_query_attribute?(conditional_statement_node)
-          when :binary
-            return conditional_statement_node if possible_query_attribute?(conditional_statement_node)
-          end
-          nil
+      def query_attribute_node(conditional_statement_node)
+        case conditional_statement_node.sexp_type
+        when :and, :or
+          node = query_attribute_node(conditional_statement_node[1]) ||
+                 query_attribute_node(conditional_statement_node[2])
+          node.file = conditional_statement_code.file
+          return node
+        when :not
+          node = query_attribute_node(conditional_statement_node[1])
+          node.file = conditional_statement_node.file
+        when :call
+          return conditional_statement_node if possible_query_attribute?(conditional_statement_node)
+        when :binary
+          return conditional_statement_node if possible_query_attribute?(conditional_statement_node)
         end
+        nil
+      end
 
         # check if the node may use query attribute instead.
         #
@@ -81,36 +82,38 @@ module RailsBestPractices
         # it is compared with an empty string.
         #
         # the node that may use query attribute.
-        def possible_query_attribute?(node)
-          return false unless :call == node.receiver.sexp_type
-          variable_node = variable(node)
-          message_node = node.grep_node(receiver: variable_node.to_s).message
+      def possible_query_attribute?(node)
+        return false unless node.receiver.sexp_type == :call
 
-          is_model?(variable_node) && model_attribute?(variable_node, message_node.to_s) &&
-            (QUERY_METHODS.include?(node.message.to_s) || compare_with_empty_string?(node))
-        end
+        variable_node = variable(node)
+        message_node = node.grep_node(receiver: variable_node.to_s).message
+
+        is_model?(variable_node) && model_attribute?(variable_node, message_node.to_s) &&
+          (QUERY_METHODS.include?(node.message.to_s) || compare_with_empty_string?(node))
+      end
 
         # check if the receiver is one of the models.
-        def is_model?(variable_node)
-          return false if variable_node.const?
-          class_name = variable_node.to_s.sub(/^@/, '').classify
-          models.include?(class_name)
-        end
+      def is_model?(variable_node)
+        return false if variable_node.const?
+
+        class_name = variable_node.to_s.sub(/^@/, '').classify
+        models.include?(class_name)
+      end
 
         # check if the receiver and message is one of the model's attribute.
         # the receiver should match one of the class model name, and the message should match one of attribute name.
-        def model_attribute?(variable_node, message)
-          class_name = variable_node.to_s.sub(/^@/, '').classify
-          attribute_type = model_attributes.get_attribute_type(class_name, message)
-          attribute_type && !%w[integer float].include?(attribute_type)
-        end
+      def model_attribute?(variable_node, message)
+        class_name = variable_node.to_s.sub(/^@/, '').classify
+        attribute_type = model_attributes.get_attribute_type(class_name, message)
+        attribute_type && !%w[integer float].include?(attribute_type)
+      end
 
         # check if the node is with node type :binary, node message :== and node argument is empty string.
-        def compare_with_empty_string?(node)
-          :binary == node.sexp_type &&
-            ['==', '!='].include?(node.message.to_s) &&
-            s(:string_literal, s(:string_content)) == node.argument
-        end
+      def compare_with_empty_string?(node)
+        node.sexp_type == :binary &&
+          ['==', '!='].include?(node.message.to_s) &&
+          s(:string_literal, s(:string_content)) == node.argument
+      end
     end
   end
 end

data/lib/rails_best_practices/reviews/use_say_with_time_in_migrations_review.rb

@@ -31,14 +31,14 @@ module RailsBestPractices
         node.body.statements.each do |child_node|
           next if child_node.grep_nodes_count(sexp_type: %i[fcall command], message: WITH_SAY_METHODS) > 0
 
-          receiver_node = if :method_add_block == child_node.sexp_type
-                           child_node[1]
-                         elsif :method_add_arg == child_node.sexp_type
-                           child_node[1]
-                         else
-                           child_node
+          receiver_node = if child_node.sexp_type == :method_add_block
+                            child_node[1]
+                          elsif child_node.sexp_type == :method_add_arg
+                            child_node[1]
+                          else
+                            child_node
                          end
-          if :call == receiver_node.sexp_type
+          if receiver_node.sexp_type == :call
             add_error('use say with time in migrations', node.file, child_node.line_number)
           end
         end

data/lib/rails_best_practices/reviews/use_scope_access_review.rb

@@ -35,23 +35,23 @@ module RailsBestPractices
         # if the conditional statement is compared with current_user or current_user.id,
         # and there is a redirect_to method call in the block body,
         # then it should be replaced by using scope access.
-        def current_user_redirect?(node)
-          all_conditions = if node.conditional_statement == node.conditional_statement.all_conditions
-            [node.conditional_statement]
-          else
-            node.conditional_statement.all_conditions
-          end
-          results = all_conditions.map do |condition_node|
-            ['==', '!='].include?(condition_node.message.to_s) &&
-              (current_user?(condition_node.argument) || current_user?(condition_node.receiver))
-          end
-          results.any? { |result| result == true } && node.body.grep_node(message: 'redirect_to')
+      def current_user_redirect?(node)
+        all_conditions = if node.conditional_statement == node.conditional_statement.all_conditions
+                           [node.conditional_statement]
+                         else
+                           node.conditional_statement.all_conditions
         end
+        results = all_conditions.map do |condition_node|
+          ['==', '!='].include?(condition_node.message.to_s) &&
+            (current_user?(condition_node.argument) || current_user?(condition_node.receiver))
+        end
+        results.any? { |result| result == true } && node.body.grep_node(message: 'redirect_to')
+      end
 
         # check a call node to see if it uses current_user, or current_user.id.
-        def current_user?(node)
-          'current_user' == node.to_s || ('current_user' == node.receiver.to_s && 'id' == node.message.to_s)
-        end
+      def current_user?(node)
+        node.to_s == 'current_user' || (node.receiver.to_s == 'current_user' && node.message.to_s == 'id')
+      end
     end
   end
 end

data/lib/rails_best_practices/reviews/use_turbo_sprockets_rails3_review.rb

@@ -18,7 +18,7 @@ module RailsBestPractices
       # check command node to see if load 'deploy/assets'
       add_callback :start_command do |node|
         if Prepares.gems.gem_version('rails').to_i == 3
-          if !Prepares.gems.has_gem?('turbo-sprockets-rails3') && 'load' == node.message.to_s && 'deploy/assets' == node.arguments.to_s
+          if !Prepares.gems.has_gem?('turbo-sprockets-rails3') && node.message.to_s == 'load' && node.arguments.to_s == 'deploy/assets'
             add_error 'speed up assets precompile with turbo-sprockets-rails3'
           end
         end

data/lib/rails_best_practices/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module RailsBestPractices
-  VERSION = '1.19.3'.freeze
+  VERSION = '1.19.4'
 end

data/rails_best_practices.gemspec

@@ -37,19 +37,19 @@ Gem::Specification.new do |s|
   s.executables   = `git ls-files -- bin/*`.split("\n").map { |f| File.basename(f) }
   s.require_paths = %w[lib assets]
 
-  s.post_install_message = <<-POST_INSTALL_MESSAGE
-#{'*' * 80}
+  s.post_install_message = <<~POST_INSTALL_MESSAGE
+    #{'*' * 80}
 
-  rails_best_practices is a code metric tool to check the quality of rails codes.
+      rails_best_practices is a code metric tool to check the quality of rails codes.
 
-  I highly recommend you browse the Rails Best Practices website first.
+      I highly recommend you browse the Rails Best Practices website first.
 
-      http://rails-bestpractices.com
+          http://rails-bestpractices.com
 
-  Enjoy!
+      Enjoy!
 
-      Richard Huang (flyerhzm@gmail.com)
+          Richard Huang (flyerhzm@gmail.com)
 
-#{'*' * 80}
+    #{'*' * 80}
   POST_INSTALL_MESSAGE
 end

data/spec/rails_best_practices/analyzer_spec.rb

@@ -106,7 +106,8 @@ module RailsBestPractices
           "\e[31mapp/models/user.rb:10 - law of demeter\e[0m",
           "\e[31mapp/models/post.rb:100 - use query attribute\e[0m",
           "\e[32m\nPlease go to https://rails-bestpractices.com to see more useful Rails Best Practices.\e[0m",
-          "\e[31m\nFound 2 warnings.\e[0m"].join("\n") + "\n")
+          "\e[31m\nFound 2 warnings.\e[0m"
+        ].join("\n") + "\n")
       end
     end
 
@@ -115,9 +116,8 @@ module RailsBestPractices
 
       subject do
         described_class.new('.',
-          'format' => 'json',
-          'output-file' => output_file
-        )
+                            'format' => 'json',
+                            'output-file' => output_file)
       end
 
       let(:check1) { Reviews::LawOfDemeterReview.new }

data/spec/rails_best_practices/core/error_spec.rb

@@ -9,7 +9,8 @@ module RailsBestPractices::Core
         filename: 'app/models/user.rb',
         line_number: '100',
         message: 'not good',
-        type: 'BogusReview').to_s).to eq('app/models/user.rb:100 - not good')
+        type: 'BogusReview'
+      ).to_s).to eq('app/models/user.rb:100 - not good')
     end
 
     it 'should return short filename' do
@@ -18,7 +19,8 @@ module RailsBestPractices::Core
         filename: '../rails-bestpractices.com/app/models/user.rb',
         line_number: '100',
         message: 'not good',
-        type: 'BogusReview').short_filename).to eq('app/models/user.rb')
+        type: 'BogusReview'
+      ).short_filename).to eq('app/models/user.rb')
     end
 
     it 'should return first line number' do
@@ -26,7 +28,8 @@ module RailsBestPractices::Core
         filename: 'app/models/user.rb',
         line_number: '50,70,100',
         message: 'not good',
-        type: 'BogusReview').first_line_number).to eq('50')
+        type: 'BogusReview'
+      ).first_line_number).to eq('50')
     end
   end
 end

data/spec/rails_best_practices/lexicals/long_line_check_spec.rb

@@ -7,14 +7,14 @@ module RailsBestPractices
     describe LongLineCheck do
       it 'should find long lines' do
         runner = Core::Runner.new(lexicals: LongLineCheck.new)
-        content = <<-EOF
-class User < ActiveRecord::Base
-# 81 Chars
-xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
-# 80 Chars
-xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
-end
-EOF
+        content = <<~EOF
+          class User < ActiveRecord::Base
+          # 81 Chars
+          xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
+          # 80 Chars
+          xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
+          end
+        EOF
         content = content.gsub("\n", "\t\n")
         runner.lexical('app/models/user.rb', content)
         expect(runner.errors.size).to eq(1)
@@ -22,14 +22,14 @@ EOF
       end
       it 'should find long lines with own max size' do
         runner = Core::Runner.new(lexicals: LongLineCheck.new('max_line_length' => 90))
-        content = <<-EOF
-class User < ActiveRecord::Base
-# 91 Chars
-xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
-# 90 Chars
-xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
-end
-EOF
+        content = <<~EOF
+          class User < ActiveRecord::Base
+          # 91 Chars
+          xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
+          # 90 Chars
+          xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
+          end
+        EOF
         content = content.gsub("\n", "\t\n")
         runner.lexical('app/models/user.rb', content)
         expect(runner.errors.size).to eq(1)
@@ -45,11 +45,11 @@ xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
       end
       it 'should not check ignored files' do
         runner = Core::Runner.new(lexicals: LongLineCheck.new(max_line_length: 80, ignored_files: /user/))
-        content = <<-EOF
-class User < ActiveRecord::Base
-# 81 Chars
-xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
-end
+        content = <<~EOF
+          class User < ActiveRecord::Base
+          # 81 Chars
+          xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
+          end
         EOF
         content = content.gsub("\n", "\t\n")
         runner.lexical('app/models/user.rb', content)

data/spec/rails_best_practices/prepares/gemfile_prepare_spec.rb

@@ -9,22 +9,22 @@ module RailsBestPractices
 
       context 'gemfile' do
         it 'should parse gems' do
-          content = <<-EOF
-GEM
-  remote: https://rubygems.org/
-  specs:
-    rails (3.2.13)
-      actionmailer (= 3.2.13)
-      actionpack (= 3.2.13)
-      activerecord (= 3.2.13)
-      activeresource (= 3.2.13)
-      activesupport (= 3.2.13)
-      bundler (~> 1.0)
-      railties (= 3.2.13)
-    mysql2 (0.3.12b6)
+          content = <<~EOF
+            GEM
+              remote: https://rubygems.org/
+              specs:
+                rails (3.2.13)
+                  actionmailer (= 3.2.13)
+                  actionpack (= 3.2.13)
+                  activerecord (= 3.2.13)
+                  activeresource (= 3.2.13)
+                  activesupport (= 3.2.13)
+                  bundler (~> 1.0)
+                  railties (= 3.2.13)
+                mysql2 (0.3.12b6)
 
-PLATFORMS
-  ruby
+            PLATFORMS
+              ruby
           EOF
           runner.prepare('Gemfile.lock', content)
           gems = Prepares.gems

data/spec/rails_best_practices/prepares/route_prepare_spec.rb

@@ -105,10 +105,11 @@ module RailsBestPractices
           runner.prepare('config/routes.rb', content)
           routes = Prepares.routes
           expect(routes.map(&:to_s)).to eq([
-            'Admin::PostsController#edit',
-            'Admin::PostsController#update',
-            'Admin::PostsController#link_to_post',
-            'Admin::PostsController#extra_update'])
+                                             'Admin::PostsController#edit',
+                                             'Admin::PostsController#update',
+                                             'Admin::PostsController#link_to_post',
+                                             'Admin::PostsController#extra_update'
+                                           ])
         end
 
         it 'should add resources routes with members inline' do
@@ -124,11 +125,12 @@ module RailsBestPractices
           runner.prepare('config/routes.rb', content)
           routes = Prepares.routes
           expect(routes.map(&:to_s)).to eq([
-            'Admin::PostsController#edit',
-            'Admin::PostsController#update',
-            'Admin::PostsController#link_to_post',
-            'Admin::PostsController#extra_update',
-            'Admin::PostsController#retrieve'])
+                                             'Admin::PostsController#edit',
+                                             'Admin::PostsController#update',
+                                             'Admin::PostsController#link_to_post',
+                                             'Admin::PostsController#extra_update',
+                                             'Admin::PostsController#retrieve'
+                                           ])
         end
 
         it 'should add connect route' do
@@ -338,12 +340,12 @@ module RailsBestPractices
           runner.prepare('config/routes.rb', content)
           routes = Prepares.routes
           expect(routes.map(&:to_s)).to eq([
-                                          'Admin::PostsController#index',
-                                          'Admin::DiscussionsController#index',
-                                          'CommentsController#index',
-                                          'UsersController#show',
-                                          'UsersController#preview'
-                                        ])
+                                             'Admin::PostsController#index',
+                                             'Admin::DiscussionsController#index',
+                                             'CommentsController#index',
+                                             'UsersController#show',
+                                             'UsersController#preview'
+                                           ])
         end
       end