rails_best_practices 1.19.2 → 1.20.1

data/lib/rails_best_practices/reviews/use_model_association_review.rb

@@ -43,24 +43,24 @@ module RailsBestPractices
 
       private
 
-        # check an attribute assignment node, if its message is xxx_id,
-        # then remember the receiver of the attribute assignment in @assignments.
-        def attribute_assignment(node)
-          if node.left_value.message.to_s =~ /_id$/
-            receiver = node.left_value.receiver.to_s
-            @assignments[receiver] = true
-          end
+      # check an attribute assignment node, if its message is xxx_id,
+      # then remember the receiver of the attribute assignment in @assignments.
+      def attribute_assignment(node)
+        if node.left_value.message.is_a?(Sexp) && node.left_value.message.to_s =~ /_id$/
+          receiver = node.left_value.receiver.to_s
+          @assignments[receiver] = true
         end
+      end
 
-        # check a call node with message "save" or "save!",
-        # if the receiver of call node exists in @assignments,
-        # then the attribute assignment should be replaced by using model association.
-        def call_assignment(node)
-          if ['save', 'save!'].include? node.message.to_s
-            receiver = node.receiver.to_s
-            add_error "use model association (for #{receiver})" if @assignments[receiver]
-          end
+      # check a call node with message "save" or "save!",
+      # if the receiver of call node exists in @assignments,
+      # then the attribute assignment should be replaced by using model association.
+      def call_assignment(node)
+        if ['save', 'save!'].include? node.message.to_s
+          receiver = node.receiver.to_s
+          add_error "use model association (for #{receiver})" if @assignments[receiver]
         end
+      end
     end
   end
 end

data/lib/rails_best_practices/reviews/use_multipart_alternative_as_content_type_of_email_review.rb

@@ -11,6 +11,7 @@ module RailsBestPractices
     # Review process:
     #   check class node to remember the class name,
     #   and check the method definition nodes to see if the corresponding mailer views exist or not.
+
     class UseMultipartAlternativeAsContentTypeOfEmailReview < Review
       interesting_nodes :class, :def
       interesting_files MAILER_FILES
@@ -31,30 +32,31 @@ module RailsBestPractices
 
       private
 
-        # check if rails's syntax mailer views are canonical.
-        #
-        # @param [String] name method name in action_mailer
-        def rails_canonical_mailer_views?(name); end
-
-        # check if rails3's syntax mailer views are canonical.
-        #
-        # @param [String] name method name in action_mailer
-        def rails3_canonical_mailer_views?(name)
-          return true if mailer_files(name).empty?
-          return true if mailer_files(name).none? { |filename| filename.index 'html' }
-          mailer_files(name).any? { |filename| filename.index 'html' } &&
-            mailer_files(name).any? { |filename| filename.index 'text' }
-        end
+      # check if rails's syntax mailer views are canonical.
+      #
+      # @param [String] name method name in action_mailer
+      def rails_canonical_mailer_views?(name); end
 
-        # all mail view files for a method name.
-        def mailer_files(name)
-          Dir.entries(mailer_directory) { |filename| filename.index name.to_s }
-        end
+      # check if rails3's syntax mailer views are canonical.
+      #
+      # @param [String] name method name in action_mailer
+      def rails3_canonical_mailer_views?(name)
+        return true if mailer_files(name).empty?
+        return true if mailer_files(name).none? { |filename| filename.index 'html' }
 
-        # the view directory of mailer.
-        def mailer_directory
-          File.join(Core::Runner.base_path, "app/views/#{@klazz_name.to_s.underscore}")
-        end
+        mailer_files(name).any? { |filename| filename.index 'html' } &&
+          mailer_files(name).any? { |filename| filename.index 'text' }
+      end
+
+      # all mail view files for a method name.
+      def mailer_files(name)
+        Dir.entries(mailer_directory) { |filename| filename.index name.to_s }
+      end
+
+      # the view directory of mailer.
+      def mailer_directory
+        File.join(Core::Runner.base_path, "app/views/#{@klazz_name.to_s.underscore}")
+      end
     end
   end
 end

data/lib/rails_best_practices/reviews/use_observer_review.rb

@@ -49,42 +49,42 @@ module RailsBestPractices
 
       private
 
-        # check a command node, if it is a callback definition, such as after_create, before_create,
-        # then save the callback methods in @callbacks
-        def remember_callback(node)
-          if node.message.to_s =~ /^after_|^before_/
-            node.arguments.all.each do |argument|
-              # ignore callback like after_create Comment.new
-              @callbacks << argument.to_s if :symbol_literal == argument.sexp_type
-            end
+      # check a command node, if it is a callback definition, such as after_create, before_create,
+      # then save the callback methods in @callbacks
+      def remember_callback(node)
+        if node.message.to_s =~ /^after_|^before_/
+          node.arguments.all.each do |argument|
+            # ignore callback like after_create Comment.new
+            @callbacks << argument.to_s if argument.sexp_type == :symbol_literal
           end
         end
+      end
 
-        # check a defn node to see if the method name exists in the @callbacks.
-        def callback_method?(node)
-          @callbacks.find { |callback| callback == node.method_name.to_s }
-        end
+      # check a defn node to see if the method name exists in the @callbacks.
+      def callback_method?(node)
+        @callbacks.find { |callback| callback == node.method_name.to_s }
+      end
 
-        # check a def node to see if it contains a actionmailer deliver call.
-        #
-        # if the message of call node is deliver,
-        # and the receiver of the call node is with receiver node who exists in @callbacks,
-        # then the call node is actionmailer deliver call.
-        def deliver_mailer?(node)
-          node.grep_nodes(sexp_type: :call) do |child_node|
-            if 'deliver' == child_node.message.to_s
-              if :method_add_arg == child_node.receiver.sexp_type &&
-                mailers.include?(child_node.receiver[1].receiver.to_s)
-                return true
-              end
+      # check a def node to see if it contains a actionmailer deliver call.
+      #
+      # if the message of call node is deliver,
+      # and the receiver of the call node is with receiver node who exists in @callbacks,
+      # then the call node is actionmailer deliver call.
+      def deliver_mailer?(node)
+        node.grep_nodes(sexp_type: :call) do |child_node|
+          if child_node.message.to_s == 'deliver'
+            if child_node.receiver.sexp_type == :method_add_arg &&
+                 mailers.include?(child_node.receiver[1].receiver.to_s)
+              return true
             end
           end
-          false
         end
+        false
+      end
 
-        def mailers
-          @mailers ||= Prepares.mailers
-        end
+      def mailers
+        @mailers ||= Prepares.mailers
+      end
     end
   end
 end

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

@@ -34,84 +34,86 @@ 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
-        end
-        all_conditions.each do |condition_node|
-          if 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,
-                      query_attribute_node.line_number
+        all_conditions =
+          if node.conditional_statement == 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,
+                    query_attribute_node.line_number
         end
       end
 
       private
 
-        # 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
+      # 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
+      end
+
+      # check if the node may use query attribute instead.
+      #
+      # if the node contains two method calls, e.g. @user.login.nil?
+      #
+      # for the first call, the receiver should be one of the class names and
+      # the message should be one of the attribute name.
+      #
+      # for the second call, the message should be one of nil?, blank? or present? or
+      # it is compared with an empty string.
+      #
+      # the node that may use query attribute.
+      def possible_query_attribute?(node)
+        return false unless node.receiver.sexp_type == :call
 
-        # check if the node may use query attribute instead.
-        #
-        # if the node contains two method calls, e.g. @user.login.nil?
-        #
-        # for the first call, the receiver should be one of the class names and
-        # the message should be one of the attribute name.
-        #
-        # for the second call, the message should be one of nil?, blank? or present? or
-        # 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
+        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
+        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
+      # check if the receiver is one of the models.
+      def is_model?(variable_node)
+        return false if variable_node.const?
 
-        # 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
+        class_name = variable_node.to_s.sub(/^@/, '').classify
+        models.include?(class_name)
+      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
+      # 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
+
+      # check if the node is with node type :binary, node message :== and node argument is empty string.
+      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,15 @@ 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
-                         end
-          if :call == receiver_node.sexp_type
+          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 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

@@ -30,28 +30,30 @@ module RailsBestPractices
 
       private
 
-        # check a if node to see
-        #
-        # 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
+      # check a if node to see
+      #
+      # 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|
+        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
+        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
+      # check a call node to see if it uses current_user, or current_user.id.
+      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,8 @@ 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.2'.freeze
+  VERSION = '1.20.1'
 end

data/rails_best_practices.gemspec

@@ -1,59 +1,54 @@
 # frozen_string_literal: true
 
-require File.expand_path('../lib/rails_best_practices/version', __FILE__)
+require File.expand_path('lib/rails_best_practices/version', __dir__)
 
-Gem::Specification.new do |s|
-  s.name        = 'rails_best_practices'
-  s.version     = RailsBestPractices::VERSION
-  s.platform    = Gem::Platform::RUBY
-  s.authors     = ['Richard Huang']
-  s.email       = ['flyerhzm@gmail.com']
-  s.homepage    = 'http://rails-bestpractices.com'
-  s.summary     = 'a code metric tool for rails codes.'
-  s.description = 'a code metric tool for rails codes, written in Ruby.'
-  s.license     = 'MIT'
+Gem::Specification.new do |spec|
+  spec.name        = 'rails_best_practices'
+  spec.version     = RailsBestPractices::VERSION
+  spec.platform    = Gem::Platform::RUBY
+  spec.authors     = ['Richard Huang']
+  spec.email       = ['flyerhzm@gmail.com']
+  spec.homepage    = 'http://rails-bestpractices.com'
+  spec.summary     = 'a code metric tool for rails codes.'
+  spec.description = 'a code metric tool for rails codes, written in Ruby.'
+  spec.license     = 'MIT'
 
-  s.required_ruby_version = '>= 1.9.0'
-  s.required_rubygems_version = '>= 1.3.6'
+  spec.required_ruby_version = '>= 1.9.0'
+  spec.required_rubygems_version = '>= 1.3.6'
 
-  s.add_dependency('activesupport')
-  # TODO: add a dependency for Rails >= 3 ?
-  s.add_dependency('code_analyzer', '>= 0.4.8')
-  s.add_dependency('erubis')
-  s.add_dependency('i18n')
-  s.add_dependency('json')
-  s.add_dependency('require_all', '~> 2.0')
-  s.add_dependency('ruby-progressbar')
+  spec.add_dependency('activesupport')
+  spec.add_dependency('code_analyzer', '>= 0.5.2')
+  spec.add_dependency('erubis')
+  spec.add_dependency('i18n')
+  spec.add_dependency('json')
+  spec.add_dependency('require_all', '~> 3.0')
+  spec.add_dependency('ruby-progressbar')
 
-  s.add_development_dependency('awesome_print')
-  s.add_development_dependency('bundler')
-  s.add_development_dependency('haml')
-  s.add_development_dependency('rake', '< 11.0')
-  s.add_development_dependency('rspec')
-  s.add_development_dependency('slim')
+  spec.add_development_dependency('awesome_print')
+  spec.add_development_dependency('bundler')
+  spec.add_development_dependency('haml')
+  spec.add_development_dependency('rake')
+  spec.add_development_dependency('rspec')
+  spec.add_development_dependency('slim')
 
-  s.files         = `git ls-files`.split("\n")
-  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
-  s.executables   = `git ls-files -- bin/*`.split("\n").map { |f| File.basename(f) }
-  s.require_paths = %w[lib assets]
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = %w[lib assets]
 
-  s.post_install_message = <<-POST_INSTALL_MESSAGE
-#{'*' * 80}
+  spec.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
 
-  Please also try our online service
+      Enjoy!
 
-      http://railsbp.com
+          Richard Huang (flyerhzm@gmail.com)
 
-  Enjoy!
-
-      Richard Huang (flyerhzm@gmail.com)
-
-#{'*' * 80}
+    #{'*' * 80}
   POST_INSTALL_MESSAGE
 end