rails_best_practices 1.19.2 → 1.20.1

data/lib/rails_best_practices/reviews/always_add_db_index_review.rb

@@ -11,7 +11,7 @@ module RailsBestPractices
     # Review process:
     #   only check the command and command_calls nodes and at the end of review process,
     #   if the receiver of command node is "create_table", then remember the table names
-    #   if the receiver of command_call node is "integer" or "string" and suffix with _id, then remember it as foreign key
+    #   if the receiver of command_call node is "integer" or "string" or "bigint" and suffix with _id, then remember it as foreign key
     #   if the receiver of command_call node is "string", the name of it is _type suffixed and there is an integer or string column _id suffixed, then remember it as polymorphic foreign key
     #   if the receiver of command_call node is remembered as foreign key and it have argument non-false "index", then remember the index columns
     #   if the receiver of command node is "add_index", then remember the index columns
@@ -40,9 +40,9 @@ module RailsBestPractices
       # if the message of command_call node is "create_table", then remember the table name.
       # if the message of command_call node is "add_index", then remember it as index columns.
       add_callback :start_command_call do |node|
-        if %w[integer string].include? node.message.to_s
+        if %w[integer string bigint].include? node.message.to_s
           remember_foreign_key_columns(node)
-        elsif 'index' == node.message.to_s
+        elsif node.message.to_s == 'index'
           remember_index_columns_inside_table(node)
         end
       end
@@ -75,120 +75,125 @@ module RailsBestPractices
         @foreign_keys.each do |table, foreign_key|
           table_node = @table_nodes[table]
           foreign_key.each do |column|
-            if not_indexed?(table, column)
-              add_error "always add db index (#{table} => [#{Array(column).join(', ')}])", table_node.file, table_node.line_number
-            end
+            next unless not_indexed?(table, column)
+
+            add_error "always add db index (#{table} => [#{Array(column).join(', ')}])",
+                      table_node.file,
+                      table_node.line_number
           end
         end
       end
 
       private
 
-        # remember the node as index columns, when used outside a table
-        # block, i.e.
-        #   add_index :table_name, :column_name
-        def remember_index_columns_outside_table(node)
-          table_name = node.arguments.all.first.to_s
-          index_column = node.arguments.all[1].to_object
+      # remember the node as index columns, when used outside a table
+      # block, i.e.
+      #   add_index :table_name, :column_name
+      def remember_index_columns_outside_table(node)
+        table_name = node.arguments.all.first.to_s
+        index_column = node.arguments.all[1].to_object
 
-          @index_columns[table_name] ||= []
-          @index_columns[table_name] << index_column
-        end
+        @index_columns[table_name] ||= []
+        @index_columns[table_name] << index_column
+      end
 
-        # remember the node as index columns, when used inside a table
-        # block, i.e.
-        #    t.index [:column_name, ...]
-        def remember_index_columns_inside_table(node)
-          table_name = @table_name
-          index_column = node.arguments.all.first.to_object
+      # remember the node as index columns, when used inside a table
+      # block, i.e.
+      #    t.index [:column_name, ...]
+      def remember_index_columns_inside_table(node)
+        table_name = @table_name
+        index_column = node.arguments.all.first.to_object
 
-          @index_columns[table_name] ||= []
-          @index_columns[table_name] << index_column
-        end
+        @index_columns[table_name] ||= []
+        @index_columns[table_name] << index_column
+      end
 
-        # remember table nodes
-        def remember_table_nodes(node)
-          @table_name = node.arguments.all.first.to_s
-          @table_nodes[@table_name] = node
-        end
+      # remember table nodes
+      def remember_table_nodes(node)
+        @table_name = node.arguments.all.first.to_s
+        @table_nodes[@table_name] = node
+      end
 
-        # remember foreign key columns
-        def remember_foreign_key_columns(node)
-          table_name = @table_name
-          foreign_key_column = node.arguments.all.first.to_s
-          @foreign_keys[table_name] ||= []
-          if foreign_key_column =~ /(.*?)_id$/
-            if @foreign_keys[table_name].delete("#{$1}_type")
-              @foreign_keys[table_name] << ["#{$1}_id", "#{$1}_type"]
+      # remember foreign key columns
+      def remember_foreign_key_columns(node)
+        table_name = @table_name
+        foreign_key_column = node.arguments.all.first.to_s
+        @foreign_keys[table_name] ||= []
+        if foreign_key_column =~ /(.*?)_id$/
+          @foreign_keys[table_name] <<
+            if @foreign_keys[table_name].delete("#{Regexp.last_match(1)}_type")
+              ["#{Regexp.last_match(1)}_id", "#{Regexp.last_match(1)}_type"]
             else
-              @foreign_keys[table_name] << foreign_key_column
+              foreign_key_column
             end
-            foreign_id_column = foreign_key_column
-          elsif foreign_key_column =~ /(.*?)_type$/
-            if @foreign_keys[table_name].delete("#{$1}_id")
-              @foreign_keys[table_name] << ["#{$1}_id", "#{$1}_type"]
+          foreign_id_column = foreign_key_column
+        elsif foreign_key_column =~ /(.*?)_type$/
+          @foreign_keys[table_name] <<
+            if @foreign_keys[table_name].delete("#{Regexp.last_match(1)}_id")
+              ["#{Regexp.last_match(1)}_id", "#{Regexp.last_match(1)}_type"]
             else
-              @foreign_keys[table_name] << foreign_key_column
+              foreign_key_column
             end
-            foreign_id_column = "#{$1}_id"
-          end
+          foreign_id_column = "#{Regexp.last_match(1)}_id"
+        end
 
-          if foreign_id_column
-            index_node = node.arguments.all.last.hash_value('index')
-            if index_node.present? && ('false' != index_node.to_s)
-              @index_columns[table_name] ||= []
-              @index_columns[table_name] << foreign_id_column
-            end
+        if foreign_id_column
+          index_node = node.arguments.all.last.hash_value('index')
+          if index_node.present? && (index_node.to_s != 'false')
+            @index_columns[table_name] ||= []
+            @index_columns[table_name] << foreign_id_column
           end
         end
+      end
 
-        # remove the non foreign keys without corresponding tables.
-        def remove_table_not_exist_foreign_keys
-          @foreign_keys.each do |table, foreign_keys|
-            foreign_keys.delete_if do |key|
-              if key =~ /_id$/
-                class_name = Prepares.model_associations.get_association_class_name(table, key[0..-4])
-                class_name ? !@table_nodes[class_name.gsub('::', '').tableize] : !@table_nodes[key[0..-4].pluralize]
-              end
+      # remove the non foreign keys without corresponding tables.
+      def remove_table_not_exist_foreign_keys
+        @foreign_keys.each do |table, foreign_keys|
+          foreign_keys.delete_if do |key|
+            if key.is_a?(String) && key =~ /_id$/
+              class_name = Prepares.model_associations.get_association_class_name(table, key[0..-4])
+              class_name ? !@table_nodes[class_name.gsub('::', '').tableize] : !@table_nodes[key[0..-4].pluralize]
             end
           end
         end
+      end
 
-        # remove the non foreign keys with only _type column.
-        def remove_only_type_foreign_keys
-          @foreign_keys.each { |_table, foreign_keys|
-            foreign_keys.delete_if { |key| key =~ /_type$/ }
-          }
+      # remove the non foreign keys with only _type column.
+      def remove_only_type_foreign_keys
+        @foreign_keys.each do |_table, foreign_keys|
+          foreign_keys.delete_if { |key| key.is_a?(String) && key =~ /_type$/ }
         end
+      end
 
-        # combine polymorphic foreign keys, e.g.
-        #     [tagger_id], [tagger_type] => [tagger_id, tagger_type]
-        def combine_polymorphic_foreign_keys
-          @index_columns.each { |_table, foreign_keys|
-            foreign_id_keys = foreign_keys.select { |key| key.size == 1 && key.first =~ /_id/ }
-            foreign_type_keys = foreign_keys.select { |key| key.size == 1 && key.first =~ /_type/ }
-            foreign_id_keys.each do |id_key|
-              if type_key = foreign_type_keys.detect { |type_key| type_key.first == id_key.first.sub(/_id/, '') + '_type' }
-                foreign_keys.delete(id_key)
-                foreign_keys.delete(type_key)
-                foreign_keys << id_key + type_key
-              end
-            end
-          }
+      # combine polymorphic foreign keys, e.g.
+      #     [tagger_id], [tagger_type] => [tagger_id, tagger_type]
+      def combine_polymorphic_foreign_keys
+        @index_columns.each do |_table, foreign_keys|
+          foreign_id_keys = foreign_keys.select { |key| key.size == 1 && key.first =~ /_id/ }
+          foreign_type_keys = foreign_keys.select { |key| key.size == 1 && key.first =~ /_type/ }
+          foreign_id_keys.each do |id_key|
+            next unless type_key =
+              foreign_type_keys.detect { |type_key| type_key.first == id_key.first.sub(/_id/, '') + '_type' }
+
+            foreign_keys.delete(id_key)
+            foreign_keys.delete(type_key)
+            foreign_keys << id_key + type_key
+          end
         end
+      end
 
-        # check if the table's column is indexed.
-        def not_indexed?(table, column)
-          index_columns = @index_columns[table]
-          !index_columns || index_columns.none? { |e| greater_than_or_equal(Array(e), Array(column)) }
-        end
+      # check if the table's column is indexed.
+      def not_indexed?(table, column)
+        index_columns = @index_columns[table]
+        !index_columns || index_columns.none? { |e| greater_than_or_equal(Array(e), Array(column)) }
+      end
 
-        # check if more_array is greater than less_array or equal to less_array.
-        def greater_than_or_equal(more_array, less_array)
-          more_size = more_array.size
-          less_size = less_array.size
-          (more_array - less_array).size == more_size - less_size
-        end
+      # check if more_array is greater than less_array or equal to less_array.
+      def greater_than_or_equal(more_array, less_array)
+        more_size = more_array.size
+        less_size = less_array.size
+        (more_array - less_array).size == more_size - less_size
+      end
     end
   end
 end

data/lib/rails_best_practices/reviews/check_destroy_return_value_review.rb

@@ -10,7 +10,17 @@ module RailsBestPractices
     #   Check all "save" calls to check the return value is used by a node we have visited.
     class CheckDestroyReturnValueReview < 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
 
       add_callback :start_if, :start_ifop, :start_elsif, :start_unless, :start_if_mod, :start_unless_mod do |node|
@@ -21,14 +31,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
@@ -36,7 +45,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

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