rails_best_practices 1.19.3 → 1.21.0

data/lib/rails_best_practices/reviews/check_save_return_value_review.rb

@@ -14,7 +14,17 @@ module RailsBestPractices
     #   Check all "save" calls to check the return value is used by a node we have visited.
     class CheckSaveReturnValueReview < Review
       include Classable
-      interesting_nodes :call, :command_call, :method_add_arg, :if, :ifop, :elsif, :unless, :if_mod, :unless_mod, :assign, :binary
+      interesting_nodes :call,
+                        :command_call,
+                        :method_add_arg,
+                        :if,
+                        :ifop,
+                        :elsif,
+                        :unless,
+                        :if_mod,
+                        :unless_mod,
+                        :assign,
+                        :binary
       interesting_files ALL_FILES
       url 'https://rails-bestpractices.com/posts/2012/11/02/check-the-return-value-of-save-otherwise-use-save/'
 
@@ -26,14 +36,13 @@ module RailsBestPractices
         @used_return_value_of = node.right_value
       end
 
+      # Consider anything used in an expression like "A or B" as used
       add_callback :start_binary do |node|
-        # Consider anything used in an expression like "A or B" as used
         if %w[&& || and or].include?(node[2].to_s)
           all_conditions = node.all_conditions
           # if our current binary is a subset of the @used_return_value_of
           # then don't overwrite it
-          already_included = @used_return_value_of &&
-            (all_conditions - @used_return_value_of).empty?
+          already_included = @used_return_value_of && (all_conditions - @used_return_value_of).empty?
 
           @used_return_value_of = node.all_conditions unless already_included
         end
@@ -41,7 +50,8 @@ module RailsBestPractices
 
       def return_value_is_used?(node)
         return false unless @used_return_value_of
-        node == @used_return_value_of or @used_return_value_of.include?(node)
+
+        (node == @used_return_value_of) || @used_return_value_of.include?(node)
       end
 
       def model_classnames
@@ -57,9 +67,11 @@ module RailsBestPractices
             end
           elsif message == 'create'
             # We're only interested in 'create' calls on model classes:
-            possible_receiver_classes = [node.receiver.to_s] + classable_modules.map do |mod|
-                "#{mod}::#{node.receiver}"
-              end
+            possible_receiver_classes =
+              [node.receiver.to_s] +
+                classable_modules.map do |mod|
+                  "#{mod}::#{node.receiver}"
+                end
             unless (possible_receiver_classes & model_classnames).empty?
               add_error "use 'create!' instead of 'create' as the latter may not always save"
             end

data/lib/rails_best_practices/reviews/default_scope_is_evil_review.rb

@@ -17,7 +17,7 @@ module RailsBestPractices
 
       # check all command nodes' message
       add_callback :start_command do |node|
-        if 'default_scope' == node.message.to_s
+        if node.message.to_s == 'default_scope'
           add_error 'default_scope is evil'
         end
       end

data/lib/rails_best_practices/reviews/dry_bundler_in_capistrano_review.rb

@@ -20,7 +20,7 @@ module RailsBestPractices
 
       # check call node to see if it is with message "namespace" and argument "bundler".
       add_callback :start_command do |node|
-        if 'namespace' == node.message.to_s && 'bundler' == node.arguments.all[0].to_s
+        if node.message.to_s == 'namespace' && node.arguments.all[0].to_s == 'bundler'
           add_error 'dry bundler in capistrano'
         end
       end

data/lib/rails_best_practices/reviews/hash_syntax_review.rb

@@ -12,7 +12,7 @@ module RailsBestPractices
       interesting_nodes :hash, :bare_assoc_hash
       interesting_files ALL_FILES
 
-      VALID_SYMBOL_KEY = /\A[@$_A-Za-z]([_\w]*[!_=?\w])?\z/
+      VALID_SYMBOL_KEY = /\A[@$_A-Za-z]([_\w]*[!_=?\w])?\z/.freeze
 
       # check hash node to see if it is ruby 1.8 style.
       add_callback :start_hash, :start_bare_assoc_hash do |node|
@@ -23,24 +23,24 @@ module RailsBestPractices
 
       protected
 
-        # check if hash node is empty.
-        def empty_hash?(node)
-          s(:hash, nil) == node || s(:bare_assoc_hash, nil) == node
-        end
+      # check if hash node is empty.
+      def empty_hash?(node)
+        s(:hash, nil) == node || s(:bare_assoc_hash, nil) == node
+      end
 
-        # check if hash key/value pairs are ruby 1.8 style.
-        def hash_is_18?(node)
-          pair_nodes = :hash == node.sexp_type ? node[1][1] : node[1]
-          return false if pair_nodes.blank?
+      # check if hash key/value pairs are ruby 1.8 style.
+      def hash_is_18?(node)
+        pair_nodes = node.sexp_type == :hash ? node[1][1] : node[1]
+        return false if pair_nodes.blank?
 
-          pair_nodes.any? { |pair_node| :symbol_literal == pair_node[1].sexp_type }
-        end
+        pair_nodes.any? { |pair_node| pair_node[1].sexp_type == :symbol_literal }
+      end
 
-        # check if the hash keys are valid to be converted to ruby 1.9
-        # syntax.
-        def valid_keys?(node)
-          node.hash_keys.all? { |key| key =~ VALID_SYMBOL_KEY }
-        end
+      # check if the hash keys are valid to be converted to ruby 1.9
+      # syntax.
+      def valid_keys?(node)
+        node.hash_keys.all? { |key| key =~ VALID_SYMBOL_KEY }
+      end
     end
   end
 end

data/lib/rails_best_practices/reviews/isolate_seed_data_review.rb

@@ -55,20 +55,20 @@ module RailsBestPractices
 
       private
 
-        # check assignment node,
-        # if the right vavlue is a method_add_arg node with message "new",
-        # then remember the left value as new variable.
-        def remember_new_variable(node)
-          right_value = node.right_value
-          if :method_add_arg == right_value.sexp_type && 'new' == right_value.message.to_s
-            @new_variables << node.left_value.to_s
-          end
+      # check assignment node,
+      # if the right vavlue is a method_add_arg node with message "new",
+      # then remember the left value as new variable.
+      def remember_new_variable(node)
+        right_value = node.right_value
+        if right_value.sexp_type == :method_add_arg && right_value.message.to_s == 'new'
+          @new_variables << node.left_value.to_s
         end
+      end
 
-        # see if the receiver of the call node is included in the @new_varaibles.
-        def new_record?(node)
-          @new_variables.include? node.receiver.to_s
-        end
+      # see if the receiver of the call node is included in the @new_varaibles.
+      def new_record?(node)
+        @new_variables.include? node.receiver.to_s
+      end
     end
   end
 end

data/lib/rails_best_practices/reviews/keep_finders_on_their_own_model_review.rb

@@ -37,17 +37,16 @@ module RailsBestPractices
 
       private
 
-        # check if the call node is the finder of other model.
-        #
-        # the message of the node should be one of find, all, first or last,
-        # and the receiver of the node should be with message :call (this is the other model),
-        # and any of its arguments is a hash,
-        # then it is the finder of other model.
-        def other_finder?(node)
-          FINDERS.include?(node[1].message.to_s) &&
-            :call == node[1].receiver.sexp_type &&
-            node.arguments.grep_nodes_count(sexp_type: :bare_assoc_hash) > 0
-        end
+      # check if the call node is the finder of other model.
+      #
+      # the message of the node should be one of find, all, first or last,
+      # and the receiver of the node should be with message :call (this is the other model),
+      # and any of its arguments is a hash,
+      # then it is the finder of other model.
+      def other_finder?(node)
+        FINDERS.include?(node[1].message.to_s) && node[1].receiver.sexp_type == :call &&
+          node.arguments.grep_nodes_count(sexp_type: :bare_assoc_hash) > 0
+      end
     end
   end
 end

data/lib/rails_best_practices/reviews/law_of_demeter_review.rb

@@ -28,40 +28,41 @@ module RailsBestPractices
       # and the message of the receiver call node matchs one of the association name with the class name,
       # then it violates the law of demeter.
       add_callback :start_call do |node|
-        if :call == node.receiver.sexp_type && need_delegate?(node)
+        if node.receiver.sexp_type == :call && need_delegate?(node)
           add_error 'law of demeter'
         end
       end
 
       private
 
-        # check if the call node can use delegate to avoid violating law of demeter.
-        #
-        # if the receiver of receiver of the call node matchs any in model names,
-        # and the message of receiver of the call node matchs any in association names,
-        # then it needs delegate.
-        def need_delegate?(node)
-          return unless variable(node)
-          class_name = variable(node).to_s.sub('@', '').classify
-          association_name = node.receiver.message.to_s
-          association = model_associations.get_association(class_name, association_name)
-          attribute_name = node.message.to_s
-          association && ASSOCIATION_METHODS.include?(association['meta']) &&
-            is_association_attribute?(association['class_name'], association_name, attribute_name)
-        end
+      # check if the call node can use delegate to avoid violating law of demeter.
+      #
+      # if the receiver of receiver of the call node matchs any in model names,
+      # and the message of receiver of the call node matchs any in association names,
+      # then it needs delegate.
+      def need_delegate?(node)
+        return unless variable(node)
 
-        def is_association_attribute?(association_class, association_name, attribute_name)
-          if association_name =~ /able$/
-            models.each do |class_name|
-              if model_associations.is_association?(class_name, association_name.sub(/able$/, '')) ||
-                model_associations.is_association?(class_name, association_name.sub(/able$/, 's'))
-                return true if model_attributes.is_attribute?(class_name, attribute_name)
-              end
+        class_name = variable(node).to_s.sub('@', '').classify
+        association_name = node.receiver.message.to_s
+        association = model_associations.get_association(class_name, association_name)
+        attribute_name = node.message.to_s
+        association && ASSOCIATION_METHODS.include?(association['meta']) &&
+          is_association_attribute?(association['class_name'], association_name, attribute_name)
+      end
+
+      def is_association_attribute?(association_class, association_name, attribute_name)
+        if association_name =~ /able$/
+          models.each do |class_name|
+            if model_associations.is_association?(class_name, association_name.sub(/able$/, '')) ||
+                 model_associations.is_association?(class_name, association_name.sub(/able$/, 's'))
+              return true if model_attributes.is_attribute?(class_name, attribute_name)
             end
-          else
-            model_attributes.is_attribute?(association_class, attribute_name)
           end
+        else
+          model_attributes.is_attribute?(association_class, attribute_name)
         end
+      end
     end
   end
 end

data/lib/rails_best_practices/reviews/move_code_into_controller_review.rb

@@ -37,10 +37,10 @@ module RailsBestPractices
 
       private
 
-        # check if the node is a finder call node.
-        def finder?(node)
-          node.receiver.const? && FINDERS.include?(node.message.to_s)
-        end
+      # check if the node is a finder call node.
+      def finder?(node)
+        node.receiver.const? && FINDERS.include?(node.message.to_s)
+      end
     end
   end
 end

data/lib/rails_best_practices/reviews/move_code_into_helper_review.rb

@@ -38,16 +38,15 @@ module RailsBestPractices
 
       private
 
-        # check if the arguments of options_for_select are complex.
-        #
-        # if the first argument is an array,
-        # and the size of array is greater than @array_count you defined,
-        # then it is complext.
-        def complex_select_options?(node)
-          'options_for_select' == node[1].message.to_s &&
-            :array == node.arguments.all.first.sexp_type &&
-            node.arguments.all.first.array_size > @array_count
-        end
+      # check if the arguments of options_for_select are complex.
+      #
+      # if the first argument is an array,
+      # and the size of array is greater than @array_count you defined,
+      # then it is complext.
+      def complex_select_options?(node)
+        node[1].message.to_s == 'options_for_select' && node.arguments.all.first.sexp_type == :array &&
+          node.arguments.all.first.array_size > @array_count
+      end
     end
   end
 end

data/lib/rails_best_practices/reviews/move_finder_to_named_scope_review.rb

@@ -29,17 +29,16 @@ module RailsBestPractices
 
       private
 
-        # check if the method_add_arg node is a finder.
-        #
-        # if the receiver of method_add_arg node is a constant,
-        # and the message of call method_add_arg is one of find, all, first or last,
-        # and any of its arguments is a hash,
-        # then it is a finder.
-        def finder?(node)
-          FINDERS.include?(node[1].message.to_s) &&
-            :call == node[1].sexp_type &&
-            node.arguments.grep_nodes_count(sexp_type: :bare_assoc_hash) > 0
-        end
+      # check if the method_add_arg node is a finder.
+      #
+      # if the receiver of method_add_arg node is a constant,
+      # and the message of call method_add_arg is one of find, all, first or last,
+      # and any of its arguments is a hash,
+      # then it is a finder.
+      def finder?(node)
+        FINDERS.include?(node[1].message.to_s) && node[1].sexp_type == :call &&
+          node.arguments.grep_nodes_count(sexp_type: :bare_assoc_hash) > 0
+      end
     end
   end
 end

data/lib/rails_best_practices/reviews/needless_deep_nesting_review.rb

@@ -51,30 +51,32 @@ module RailsBestPractices
 
       private
 
-        # check nested route.
-        #
-        # if the receiver of the method_add_block is with message "resources" or "resource",
-        # then increment the @counter, recursively check the block body, and decrement the @counter.
-        #
-        # if the node type is command_call or command,
-        # and its message is resources or resource,
-        # then check if @counter is greater than or equal to @nested_count,
-        # if so, it is the needless deep nesting.
-        def recursively_check(node)
-          shallow = @shallow_nodes.include? node
-          if %i[command_call command].include?(node[1].sexp_type) && %w[resources resource].include?(node[1].message.to_s)
-            hash_node = node[1].arguments.grep_node(sexp_type: :bare_assoc_hash)
-            shallow ||= (hash_node && 'true' == hash_node.hash_value('shallow').to_s)
-            @counter += 1
-            node.block_node.statements.each do |stmt_node|
-              @shallow_nodes << stmt_node if shallow
-              recursively_check(stmt_node)
-            end
-            @counter -= 1
-          elsif %i[command_call command].include?(node.sexp_type) && %w[resources resource].include?(node.message.to_s)
-            add_error "needless deep nesting (nested_count > #{@nested_count})", @file, node.line_number if @counter >= @nested_count && !@shallow_nodes.include?(node)
+      # check nested route.
+      #
+      # if the receiver of the method_add_block is with message "resources" or "resource",
+      # then increment the @counter, recursively check the block body, and decrement the @counter.
+      #
+      # if the node type is command_call or command,
+      # and its message is resources or resource,
+      # then check if @counter is greater than or equal to @nested_count,
+      # if so, it is the needless deep nesting.
+      def recursively_check(node)
+        shallow = @shallow_nodes.include? node
+
+        if %i[command_call command].include?(node[1].sexp_type) && %w[resources resource].include?(node[1].message.to_s)
+          hash_node = node[1].arguments.grep_node(sexp_type: :bare_assoc_hash)
+          shallow ||= (hash_node && hash_node.hash_value('shallow').to_s == 'true')
+          @counter += 1
+          node.block_node.statements.each do |stmt_node|
+            @shallow_nodes << stmt_node if shallow
+            recursively_check(stmt_node)
           end
+          @counter -= 1
+        elsif %i[command_call command].include?(node.sexp_type) && %w[resources resource].include?(node.message.to_s)
+          add_error "needless deep nesting (nested_count > #{@nested_count})", @file, node.line_number if @counter >=
+            @nested_count && !@shallow_nodes.include?(node)
         end
+      end
     end
   end
 end

data/lib/rails_best_practices/reviews/not_rescue_exception_review.rb

@@ -18,7 +18,7 @@ module RailsBestPractices
 
       # check rescue node to see if its type is Exception
       add_callback :start_rescue do |rescue_node|
-        if rescue_node.exception_classes.any? { |rescue_class| 'Exception' == rescue_class.to_s }
+        if rescue_node.exception_classes.any? { |rescue_class| rescue_class.to_s == 'Exception' }
           add_error "Don't rescue Exception", rescue_node.file, rescue_node.exception_classes.first.line_number
         end
       end

data/lib/rails_best_practices/reviews/not_use_default_route_review.rb

@@ -24,8 +24,7 @@ module RailsBestPractices
 
       # check all command nodes
       add_callback :start_command do |node|
-        if 'match' == node.message.to_s &&
-          ':controller(/:action(/:id(.:format)))' == node.arguments.all.first.to_s
+        if node.message.to_s == 'match' && node.arguments.all.first.to_s == ':controller(/:action(/:id(.:format)))'
           add_error 'not use default route'
         end
       end

data/lib/rails_best_practices/reviews/not_use_time_ago_in_words_review.rb

@@ -17,7 +17,7 @@ module RailsBestPractices
 
       # check fcall node to see if its message is time_ago_in_words or distance_of_time_in_words_to_now
       add_callback :start_fcall do |node|
-        if 'time_ago_in_words' == node.message.to_s || 'distance_of_time_in_words_to_now' == node.message.to_s
+        if node.message.to_s == 'time_ago_in_words' || node.message.to_s == 'distance_of_time_in_words_to_now'
           add_error 'not use time_ago_in_words'
         end
       end

data/lib/rails_best_practices/reviews/overuse_route_customizations_review.rb

@@ -41,14 +41,14 @@ module RailsBestPractices
 
       private
 
-        # check method_add_block node to calculate the count of member and collection custom routes.
-        #
-        # if its receiver is with message "resources",
-        # then calculate the count of call nodes, whose message is get, post, update or delete,
-        # it is just the count of member and collection custom routes.
-        def member_and_collection_count_for_rails3(node)
-          'resources' == node[1].message.to_s ? node.grep_nodes_count(sexp_type: :command, message: VERBS) : 0
-        end
+      # check method_add_block node to calculate the count of member and collection custom routes.
+      #
+      # if its receiver is with message "resources",
+      # then calculate the count of call nodes, whose message is get, post, update or delete,
+      # it is just the count of member and collection custom routes.
+      def member_and_collection_count_for_rails3(node)
+        node[1].message.to_s == 'resources' ? node.grep_nodes_count(sexp_type: :command, message: VERBS) : 0
+      end
     end
   end
 end

data/lib/rails_best_practices/reviews/protect_mass_assignment_review.rb

@@ -11,6 +11,7 @@ module RailsBestPractices
     # Review process:
     #   check nodes to see if there is a command with message attr_accessible or attr_protected,
     #   or include ActiveModel::ForbiddenAttributesProtection.
+
     class ProtectMassAssignmentReview < Review
       interesting_files MODEL_FILES
       interesting_nodes :class, :command, :var_ref, :vcall, :fcall
@@ -54,53 +55,55 @@ module RailsBestPractices
 
       private
 
-        def check_activerecord_version
-          if Prepares.gems.gem_version('activerecord').to_i > 3
-            @mass_assignement = false
-          end
+      def check_activerecord_version
+        if Prepares.gems.gem_version('activerecord').to_i > 3
+          @mass_assignement = false
         end
+      end
 
-        def check_whitelist_attributes_config
-          if 'true' == Prepares.configs['config.active_record.whitelist_attributes']
-            @whitelist_attributes = true
-          end
+      def check_whitelist_attributes_config
+        if Prepares.configs['config.active_record.whitelist_attributes'] == 'true'
+          @whitelist_attributes = true
         end
+      end
 
-        def check_include_forbidden_attributes_protection_config
-          if 'true' == Prepares.configs['railsbp.include_forbidden_attributes_protection']
-            @mass_assignement = false
-          end
+      def check_include_forbidden_attributes_protection_config
+        if Prepares.configs['railsbp.include_forbidden_attributes_protection'] == 'true'
+          @mass_assignement = false
         end
+      end
 
-        def check_rails_builtin(node)
-          if @whitelist_attributes || [node.to_s, node.message.to_s].any? { |str| %w[attr_accessible attr_protected].include? str }
-            @mass_assignement = false
-          end
+      def check_rails_builtin(node)
+        if @whitelist_attributes ||
+             [node.to_s, node.message.to_s].any? { |str| %w[attr_accessible attr_protected].include? str }
+          @mass_assignement = false
         end
+      end
 
-        def check_strong_parameters(command_node)
-          if 'include' == command_node.message.to_s && 'ActiveModel::ForbiddenAttributesProtection' == command_node.arguments.all.first.to_s
-            @mass_assignement = false
-          end
+      def check_strong_parameters(command_node)
+        if command_node.message.to_s == 'include' &&
+             command_node.arguments.all.first.to_s == 'ActiveModel::ForbiddenAttributesProtection'
+          @mass_assignement = false
         end
+      end
 
-        def check_devise(command_node)
-          if 'devise' == command_node.message.to_s
-            @mass_assignement = false
-          end
+      def check_devise(command_node)
+        if command_node.message.to_s == 'devise'
+          @mass_assignement = false
         end
+      end
 
-        def check_authlogic(node)
-          if [node.to_s, node.message.to_s].include? 'acts_as_authentic'
-            @mass_assignement = false
-          end
+      def check_authlogic(node)
+        if [node.to_s, node.message.to_s].include? 'acts_as_authentic'
+          @mass_assignement = false
         end
+      end
 
-        def check_active_record(const_path_ref_node)
-          if 'ActiveRecord::Base' != const_path_ref_node.base_class.to_s
-            @mass_assignement = false
-          end
+      def check_active_record(const_path_ref_node)
+        if const_path_ref_node.base_class.to_s != 'ActiveRecord::Base'
+          @mass_assignement = false
         end
+      end
     end
   end
 end