rails_best_practices 1.19.3 → 1.19.4

data/lib/rails_best_practices/prepares/route_prepare.rb

@@ -27,21 +27,21 @@ module RailsBestPractices
           first_argument = node.arguments.all.first
           second_argument = node.arguments.all[1]
           if @controller_names.last
-            if :bare_assoc_hash == first_argument.sexp_type
+            if first_argument.sexp_type == :bare_assoc_hash
               action_names = [first_argument.hash_values.first.to_s]
-            elsif :array == first_argument.sexp_type
+            elsif first_argument.sexp_type == :array
               action_names = first_argument.array_values.map(&:to_s)
-            elsif :bare_assoc_hash == second_argument.try(:sexp_type) && second_argument.hash_value('to').present?
-              if :string_literal == second_argument.hash_value('to').sexp_type
+            elsif second_argument.try(:sexp_type) == :bare_assoc_hash && second_argument.hash_value('to').present?
+              if second_argument.hash_value('to').sexp_type == :string_literal
                 controller_name, action_name = second_argument.hash_value('to').to_s.split('#')
                 action_names = [action_name]
               else
                 action_names = [second_argument.hash_value('to').to_s]
               end
-            elsif :symbol_literal == first_argument.sexp_type && second_argument.try(:sexp_type) && \
-              :symbol_literal == second_argument.sexp_type
+            elsif first_argument.sexp_type == :symbol_literal && second_argument.try(:sexp_type) && \
+                  second_argument.sexp_type == :symbol_literal
               action_names = node.arguments.all.select \
-                { |arg| :symbol_literal == arg.sexp_type }.map(&:to_s)
+                { |arg| arg.sexp_type == :symbol_literal }.map(&:to_s)
             else
               action_names = [first_argument.to_s]
             end
@@ -49,18 +49,18 @@ module RailsBestPractices
               @routes.add_route(current_namespaces, current_controller_name, action_name)
             end
           else
-            if :bare_assoc_hash == first_argument.sexp_type
+            if first_argument.sexp_type == :bare_assoc_hash
               route_node = first_argument.hash_values.first
               # do not parse redirect block
-              if :method_add_arg != route_node.sexp_type
+              if route_node.sexp_type != :method_add_arg
                 controller_name, action_name = route_node.to_s.split('#')
                 @routes.add_route(current_namespaces, controller_name.underscore, action_name)
               end
-            elsif :array == first_argument.sexp_type
+            elsif first_argument.sexp_type == :array
               first_argument.array_values.map(&:to_s).each do |action_node|
                 @routes.add_route(current_namespaces, controller_name, action_node.to_s)
               end
-            elsif :bare_assoc_hash == second_argument.try(:sexp_type)
+            elsif second_argument.try(:sexp_type) == :bare_assoc_hash
               if second_argument.hash_value('to').present?
                 controller_name, action_name = second_argument.hash_value('to').to_s.split('#')
               else
@@ -78,12 +78,13 @@ module RailsBestPractices
           case options.sexp_type
           when :bare_assoc_hash
             if options.hash_value('controller').present?
-              return if :regexp_literal == options.hash_value('controller').sexp_type
+              return if options.hash_value('controller').sexp_type == :regexp_literal
+
               controller_name = options.hash_value('controller').to_s
               action_name = options.hash_value('action').present? ? options.hash_value('action').to_s : '*'
               @routes.add_route(current_namespaces, controller_name, action_name)
             else
-              route_node = options.hash_values.find { |value_node| :string_literal == value_node.sexp_type && value_node.to_s.include?('#') }
+              route_node = options.hash_values.find { |value_node| value_node.sexp_type == :string_literal && value_node.to_s.include?('#') }
               if route_node.present?
                 controller_name, action_name = route_node.to_s.split('#')
                 @routes.add_route(current_namespaces, controller_name.underscore, action_name)
@@ -100,7 +101,7 @@ module RailsBestPractices
           options = node.arguments.all.last
           case options.sexp_type
           when :bare_assoc_hash
-            route_node = options.hash_values.find { |value_node| :string_literal == value_node.sexp_type && value_node.to_s.include?('#') }
+            route_node = options.hash_values.find { |value_node| value_node.sexp_type == :string_literal && value_node.to_s.include?('#') }
             if route_node.present?
               controller_name, action_name = route_node.to_s.split('#')
               @routes.add_route(current_namespaces, controller_name.underscore, action_name)
@@ -151,7 +152,7 @@ module RailsBestPractices
           end
         when 'with_options'
           argument = node.arguments.all.last
-          if :bare_assoc_hash == argument.sexp_type && argument.hash_value('controller').present?
+          if argument.sexp_type == :bare_assoc_hash && argument.hash_value('controller').present?
             @controller_name = [:with_option, argument.hash_value('controller').to_s]
           end
         else

data/lib/rails_best_practices/prepares/schema_prepare.rb

@@ -15,7 +15,7 @@ module RailsBestPractices
       end
 
       add_callback :start_command do |node|
-        if 'create_table' == node.message.to_s
+        if node.message.to_s == 'create_table'
           @last_klazz = node.arguments.all.first.to_s.classify
         end
       end

data/lib/rails_best_practices/reviews/add_model_virtual_attribute_review.rb

@@ -48,44 +48,46 @@ module RailsBestPractices
 
         # check an attribute assignment node, if there is a array reference node in the right value of assignment node,
         # then remember this attribute assignment.
-        def assign(node)
-          left_value = node.left_value
-          right_value = node.right_value
-          return unless :field == left_value.sexp_type && :call == right_value.sexp_type
-          aref_node = right_value.grep_node(sexp_type: :aref)
-          if aref_node
-            assignments(left_value.receiver.to_s) << { message: left_value.message.to_s, arguments: aref_node.to_s }
-          end
+      def assign(node)
+        left_value = node.left_value
+        right_value = node.right_value
+        return unless left_value.sexp_type == :field && right_value.sexp_type == :call
+
+        aref_node = right_value.grep_node(sexp_type: :aref)
+        if aref_node
+          assignments(left_value.receiver.to_s) << { message: left_value.message.to_s, arguments: aref_node.to_s }
         end
+      end
 
         # check a call node with message "save" or "save!",
         # if there exists an attribute assignment for the receiver of this call node,
         # and if the arguments of this attribute assignments has duplicated entries (different message and same arguments),
         # then this node needs to add a virtual attribute.
-        def call_assignment(node)
-          if ['save', 'save!'].include? node.message.to_s
-            receiver = node.receiver.to_s
-            add_error "add model virtual attribute (for #{receiver})" if params_dup?(assignments(receiver).collect { |h| h[:arguments] })
-          end
+      def call_assignment(node)
+        if ['save', 'save!'].include? node.message.to_s
+          receiver = node.receiver.to_s
+          add_error "add model virtual attribute (for #{receiver})" if params_dup?(assignments(receiver).collect { |h| h[:arguments] })
         end
+      end
 
         # if the nodes are duplicated.
-        def params_dup?(nodes)
-          return false if nodes.nil?
-          !dups(nodes).empty?
-        end
+      def params_dup?(nodes)
+        return false if nodes.nil?
+
+        !dups(nodes).empty?
+      end
 
         # get the assignments of receiver.
-        def assignments(receiver)
-          @assignments[receiver] ||= []
-        end
+      def assignments(receiver)
+        @assignments[receiver] ||= []
+      end
 
         # Get the duplicate entries from an Enumerable.
         #
         # @return [Enumerable] the duplicate entries.
-        def dups(nodes)
-          nodes.inject({}) { |h, v| h[v] = h[v].to_i + 1; h }.reject { |_k, v| v == 1 }.keys
-        end
+      def dups(nodes)
+        nodes.each_with_object({}) { |v, h| h[v] = h[v].to_i + 1; }.reject { |_k, v| v == 1 }.keys
+      end
     end
   end
 end

data/lib/rails_best_practices/reviews/always_add_db_index_review.rb

@@ -42,7 +42,7 @@ module RailsBestPractices
       add_callback :start_command_call do |node|
         if %w[integer string].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
@@ -87,107 +87,108 @@ module RailsBestPractices
         # 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
+      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
+      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
+      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"]
-            else
-              @foreign_keys[table_name] << 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"]
-            else
-              @foreign_keys[table_name] << foreign_key_column
-            end
-            foreign_id_column = "#{$1}_id"
+      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"]
+          else
+            @foreign_keys[table_name] << 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"]
+          else
+            @foreign_keys[table_name] << foreign_key_column
           end
+          foreign_id_column = "#{$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
+      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
           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$/ }
-          }
+      def remove_only_type_foreign_keys
+        @foreign_keys.each do |_table, foreign_keys|
+          foreign_keys.delete_if { |key| 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|
-              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
-          }
+      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
+      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
+      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

@@ -28,7 +28,7 @@ module RailsBestPractices
           # 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?
+                             (all_conditions - @used_return_value_of).empty?
 
           @used_return_value_of = node.all_conditions unless already_included
         end
@@ -36,6 +36,7 @@ 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)
       end
 

data/lib/rails_best_practices/reviews/check_save_return_value_review.rb

@@ -33,7 +33,7 @@ module RailsBestPractices
           # 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?
+                             (all_conditions - @used_return_value_of).empty?
 
           @used_return_value_of = node.all_conditions unless already_included
         end
@@ -41,6 +41,7 @@ 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)
       end
 
@@ -58,8 +59,8 @@ module RailsBestPractices
           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
+                                                                 "#{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

@@ -24,23 +24,23 @@ module RailsBestPractices
       protected
 
         # check if hash node is empty.
-        def empty_hash?(node)
-          s(:hash, nil) == node || s(:bare_assoc_hash, nil) == node
-        end
+      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?
+      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
+      def valid_keys?(node)
+        node.hash_keys.all? { |key| key =~ VALID_SYMBOL_KEY }
+      end
     end
   end
 end